+1999-10-05 Tor Lillqvist <tml@iki.fi>
+
+ * gdk/win32/*.[ch]: Corresponding changes as in X11 backend.
+
+ * gdk/win32/gdkcompat.c: New file, actually provide an
+ implementation for the deprecated functions. (Just temporarily.)
+
+ * gtk/gtkfilesel.c: Fix an #ifdef syntax botch.
+
+ * gtk/makefile.{cygwin,msc}: Update gdk_headers.
+
+ * gdk/win32/gdk.def gtk/gtk.def: Updates.
+
1999-10-05 Kjartan Maraas <kmaraas@online.no>
* configure.in: Added "uk" to ALL_LINGUAS.
+1999-10-05 Tor Lillqvist <tml@iki.fi>
+
+ * gdk/win32/*.[ch]: Corresponding changes as in X11 backend.
+
+ * gdk/win32/gdkcompat.c: New file, actually provide an
+ implementation for the deprecated functions. (Just temporarily.)
+
+ * gtk/gtkfilesel.c: Fix an #ifdef syntax botch.
+
+ * gtk/makefile.{cygwin,msc}: Update gdk_headers.
+
+ * gdk/win32/gdk.def gtk/gtk.def: Updates.
+
1999-10-05 Kjartan Maraas <kmaraas@online.no>
* configure.in: Added "uk" to ALL_LINGUAS.
+1999-10-05 Tor Lillqvist <tml@iki.fi>
+
+ * gdk/win32/*.[ch]: Corresponding changes as in X11 backend.
+
+ * gdk/win32/gdkcompat.c: New file, actually provide an
+ implementation for the deprecated functions. (Just temporarily.)
+
+ * gtk/gtkfilesel.c: Fix an #ifdef syntax botch.
+
+ * gtk/makefile.{cygwin,msc}: Update gdk_headers.
+
+ * gdk/win32/gdk.def gtk/gtk.def: Updates.
+
1999-10-05 Kjartan Maraas <kmaraas@online.no>
* configure.in: Added "uk" to ALL_LINGUAS.
+1999-10-05 Tor Lillqvist <tml@iki.fi>
+
+ * gdk/win32/*.[ch]: Corresponding changes as in X11 backend.
+
+ * gdk/win32/gdkcompat.c: New file, actually provide an
+ implementation for the deprecated functions. (Just temporarily.)
+
+ * gtk/gtkfilesel.c: Fix an #ifdef syntax botch.
+
+ * gtk/makefile.{cygwin,msc}: Update gdk_headers.
+
+ * gdk/win32/gdk.def gtk/gtk.def: Updates.
+
1999-10-05 Kjartan Maraas <kmaraas@online.no>
* configure.in: Added "uk" to ALL_LINGUAS.
+1999-10-05 Tor Lillqvist <tml@iki.fi>
+
+ * gdk/win32/*.[ch]: Corresponding changes as in X11 backend.
+
+ * gdk/win32/gdkcompat.c: New file, actually provide an
+ implementation for the deprecated functions. (Just temporarily.)
+
+ * gtk/gtkfilesel.c: Fix an #ifdef syntax botch.
+
+ * gtk/makefile.{cygwin,msc}: Update gdk_headers.
+
+ * gdk/win32/gdk.def gtk/gtk.def: Updates.
+
1999-10-05 Kjartan Maraas <kmaraas@online.no>
* configure.in: Added "uk" to ALL_LINGUAS.
+1999-10-05 Tor Lillqvist <tml@iki.fi>
+
+ * gdk/win32/*.[ch]: Corresponding changes as in X11 backend.
+
+ * gdk/win32/gdkcompat.c: New file, actually provide an
+ implementation for the deprecated functions. (Just temporarily.)
+
+ * gtk/gtkfilesel.c: Fix an #ifdef syntax botch.
+
+ * gtk/makefile.{cygwin,msc}: Update gdk_headers.
+
+ * gdk/win32/gdk.def gtk/gtk.def: Updates.
+
1999-10-05 Kjartan Maraas <kmaraas@online.no>
* configure.in: Added "uk" to ALL_LINGUAS.
+1999-10-05 Tor Lillqvist <tml@iki.fi>
+
+ * gdk/win32/*.[ch]: Corresponding changes as in X11 backend.
+
+ * gdk/win32/gdkcompat.c: New file, actually provide an
+ implementation for the deprecated functions. (Just temporarily.)
+
+ * gtk/gtkfilesel.c: Fix an #ifdef syntax botch.
+
+ * gtk/makefile.{cygwin,msc}: Update gdk_headers.
+
+ * gdk/win32/gdk.def gtk/gtk.def: Updates.
+
1999-10-05 Kjartan Maraas <kmaraas@online.no>
* configure.in: Added "uk" to ALL_LINGUAS.
gdk_draw_string
gdk_draw_text
gdk_draw_text_wc
+ gdk_drawable_get_colormap
+ gdk_drawable_get_size
+ gdk_drawable_get_type
+ gdk_drawable_get_visual
+ gdk_drawable_set_colormap
gdk_drawable_set_data
gdk_error_code
gdk_error_trap_pop
{
gint return_val;
- return_val = gdk_root_parent.width;
+ return_val = gdk_root_parent.drawable.width;
return return_val;
}
{
gint return_val;
- return_val = gdk_root_parent.height;
+ return_val = gdk_root_parent.drawable.height;
return return_val;
}
gdk_draw_string
gdk_draw_text
gdk_draw_text_wc
+ gdk_drawable_get_colormap
+ gdk_drawable_get_size
+ gdk_drawable_get_type
+ gdk_drawable_get_visual
+ gdk_drawable_set_colormap
gdk_drawable_set_data
gdk_error_code
gdk_error_trap_pop
{
GdkCursorPrivate *private;
GdkCursor *cursor;
- GdkPixmapPrivate *source_private, *mask_private;
+ GdkDrawablePrivate *source_private, *mask_private;
GdkImage *source_image, *mask_image;
HCURSOR xcursor;
guchar *p, *q, *XORmask, *ANDmask;
g_return_val_if_fail (source != NULL, NULL);
g_return_val_if_fail (mask != NULL, NULL);
- source_private = (GdkPixmapPrivate *) source;
- mask_private = (GdkPixmapPrivate *) mask;
+ source_private = (GdkDrawablePrivate *) source;
+ mask_private = (GdkDrawablePrivate *) mask;
g_return_val_if_fail (source_private->width == mask_private->width
&& source_private->height == mask_private->height,
{
GdkCursorPrivate *private;
GdkCursor *cursor;
- GdkPixmapPrivate *source_private, *mask_private;
+ GdkDrawablePrivate *source_private, *mask_private;
GdkImage *source_image, *mask_image;
HCURSOR xcursor;
guchar *p, *q, *XORmask, *ANDmask;
g_return_val_if_fail (source != NULL, NULL);
g_return_val_if_fail (mask != NULL, NULL);
- source_private = (GdkPixmapPrivate *) source;
- mask_private = (GdkPixmapPrivate *) mask;
+ source_private = (GdkDrawablePrivate *) source;
+ mask_private = (GdkDrawablePrivate *) mask;
g_return_val_if_fail (source_private->width == mask_private->width
&& source_private->height == mask_private->height,
GdkDragProtocol *protocol)
{
GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
- GdkWindowPrivate *drag_window_private = (GdkWindowPrivate *) drag_window;
+ GdkDrawablePrivate *drag_window_private = (GdkDrawablePrivate*) drag_window;
HWND recipient;
POINT pt;
void
gdk_window_register_dnd (GdkWindow *window)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *) window;
+ GdkDrawablePrivate *private = (GdkDrawablePrivate *) window;
#ifdef OLE2_DND
target_drag_context *context;
HRESULT hres;
GdkDragProtocol *protocol)
{
GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
- GdkWindowPrivate *drag_window_private = (GdkWindowPrivate *) drag_window;
+ GdkDrawablePrivate *drag_window_private = (GdkDrawablePrivate*) drag_window;
HWND recipient;
POINT pt;
void
gdk_window_register_dnd (GdkWindow *window)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *) window;
+ GdkDrawablePrivate *private = (GdkDrawablePrivate *) window;
#ifdef OLE2_DND
target_drag_context *context;
HRESULT hres;
#include "gdkdrawable.h"
#include "gdkprivate.h"
+#include "gdkwindow.h"
+#include "gdkx.h"
#ifndef G_PI
#define G_PI 3.14159265358979323846
#endif
+/* Manipulation of drawables
+ */
+void
+gdk_drawable_set_data (GdkDrawable *drawable,
+ const gchar *key,
+ gpointer data,
+ GDestroyNotify destroy_func)
+{
+ g_dataset_set_data_full (drawable, key, data, destroy_func);
+}
+
+void
+gdk_drawable_get_data (GdkDrawable *drawable,
+ const gchar *key)
+{
+ g_dataset_get_data (drawable, key);
+}
+
+GdkDrawableType
+gdk_drawable_get_type (GdkDrawable *drawable)
+{
+ g_return_val_if_fail (drawable != NULL, (GdkDrawableType) -1);
+
+ return GDK_DRAWABLE_TYPE (drawable);
+}
+
+void
+gdk_drawable_get_size (GdkDrawable *drawable,
+ gint *width,
+ gint *height)
+{
+ GdkDrawablePrivate *drawable_private;
+
+ g_return_if_fail (drawable != NULL);
+
+ drawable_private = (GdkDrawablePrivate*) drawable;
+
+ if (width)
+ *width = drawable_private->width;
+ if (height)
+ *height = drawable_private->height;
+}
+
+void
+gdk_drawable_set_colormap (GdkDrawable *drawable,
+ GdkColormap *colormap)
+{
+ GdkDrawablePrivate *drawable_private;
+ GdkColormapPrivate *colormap_private;
+
+ g_return_if_fail (drawable != NULL);
+ g_return_if_fail (colormap != NULL);
+
+ drawable_private = (GdkDrawablePrivate*) drawable;
+ colormap_private = (GdkColormapPrivate*) colormap;
+
+ if (!GDK_DRAWABLE_DESTROYED (drawable))
+ {
+ if (GDK_IS_WINDOW (drawable))
+ {
+ g_return_if_fail (colormap_private->visual !=
+ ((GdkColormapPrivate*)(drawable_private->colormap))->visual);
+ /* XXX ??? */
+ GDK_NOTE (MISC, g_print ("gdk_drawable_set_colormap: %#x %#x\n",
+ GDK_DRAWABLE_XID (drawable),
+ colormap_private->xcolormap));
+ }
+ if (drawable_private->colormap)
+ gdk_colormap_unref (drawable_private->colormap);
+ drawable_private->colormap = colormap;
+ gdk_colormap_ref (drawable_private->colormap);
+
+ if (GDK_IS_WINDOW (drawable) &&
+ drawable_private->window_type != GDK_WINDOW_TOPLEVEL)
+ gdk_window_add_colormap_windows (drawable);
+ }
+}
+
+GdkColormap*
+gdk_drawable_get_colormap (GdkDrawable *drawable)
+{
+ GdkDrawablePrivate *drawable_private;
+
+ g_return_val_if_fail (drawable != NULL, NULL);
+ drawable_private = (GdkDrawablePrivate*) drawable;
+
+ if (!GDK_DRAWABLE_DESTROYED (drawable))
+ {
+ if (drawable_private->colormap == NULL)
+ return gdk_colormap_get_system (); /* XXX ??? */
+ else
+ return drawable_private->colormap;
+ }
+
+ return NULL;
+}
+
+GdkVisual*
+gdk_drawable_get_visual (GdkDrawable *drawable)
+{
+ GdkColormap *colormap;
+
+ g_return_val_if_fail (drawable != NULL, NULL);
+
+ colormap = gdk_drawable_get_colormap (drawable);
+ return colormap ? gdk_colormap_get_visual (colormap) : NULL;
+}
+
void
gdk_draw_point (GdkDrawable *drawable,
GdkGC *gc,
gint x,
gint y)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkGCPrivate *gc_private;
HDC hdc;
g_return_if_fail (drawable != NULL);
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
hdc = gdk_gc_predraw (drawable_private, gc_private);
gint x2,
gint y2)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkGCPrivate *gc_private;
HDC hdc;
g_return_if_fail (drawable != NULL);
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
hdc = gdk_gc_predraw (drawable_private, gc_private);
gint width,
gint height)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkGCPrivate *gc_private;
HDC hdc;
HGDIOBJ oldpen, oldbrush;
g_return_if_fail (drawable != NULL);
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
if (width == -1)
gint angle1,
gint angle2)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkGCPrivate *gc_private;
HDC hdc;
int nXStartArc, nYStartArc, nXEndArc, nYEndArc;
g_return_if_fail (drawable != NULL);
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
if (width == -1)
GdkPoint *points,
gint npoints)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkGCPrivate *gc_private;
HDC hdc;
POINT *pts;
g_return_if_fail (drawable != NULL);
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
GDK_NOTE (MISC, g_print ("gdk_draw_polygon: %#x (%d) %d\n",
const gchar *text,
gint text_length)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkFontPrivate *font_private;
GdkGCPrivate *gc_private;
HDC hdc;
g_return_if_fail (gc != NULL);
g_return_if_fail (text != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
font_private = (GdkFontPrivate*) font;
const GdkWChar *text,
gint text_length)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkFontPrivate *font_private;
GdkGCPrivate *gc_private;
gint i;
g_return_if_fail (gc != NULL);
g_return_if_fail (text != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
font_private = (GdkFontPrivate*) font;
gint width,
gint height)
{
- GdkWindowPrivate *drawable_private;
- GdkWindowPrivate *src_private;
+ GdkDrawablePrivate *drawable_private;
+ GdkDrawablePrivate *src_private;
GdkGCPrivate *gc_private;
HDC hdc;
HDC srcdc;
g_return_if_fail (src != NULL);
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- src_private = (GdkWindowPrivate*) src;
- if (drawable_private->destroyed || src_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable) || GDK_DRAWABLE_DESTROYED (src))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
+ src_private = (GdkDrawablePrivate*) src;
gc_private = (GdkGCPrivate*) gc;
if (width == -1)
SetRectEmpty (&r);
outside_rgn = CreateRectRgnIndirect (&r);
- if (drawable_private->window_type != GDK_WINDOW_PIXMAP)
+ if (drawable_private->window_type != GDK_DRAWABLE_PIXMAP)
{
/* If we are drawing on a window, calculate the region that is
* outside the source pixmap, and invalidate that, causing it to
/* Strangely enough, this function is called also to bitblt
* from a window.
*/
- if (src_private->window_type == GDK_WINDOW_PIXMAP)
+ if (src_private->window_type == GDK_DRAWABLE_PIXMAP)
{
if ((srcdc = CreateCompatibleDC (hdc)) == NULL)
g_warning ("gdk_draw_pixmap: CreateCompatibleDC failed");
GdkPoint *points,
gint npoints)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkGCPrivate *gc_private;
HDC hdc;
int i;
g_return_if_fail ((points != NULL) && (npoints > 0));
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
hdc = gdk_gc_predraw (drawable_private, gc_private);
GdkSegment *segs,
gint nsegs)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkGCPrivate *gc_private;
HDC hdc;
int i;
g_return_if_fail (segs != NULL);
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
hdc = gdk_gc_predraw (drawable_private, gc_private);
GdkPoint *points,
gint npoints)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkGCPrivate *gc_private;
HDC hdc;
POINT *pts;
g_return_if_fail (points != NULL);
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
+ if (GDK_DRAWABLE_DESTROYED (drawable))
+ return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
hdc = gdk_gc_predraw (drawable_private, gc_private);
#include "gdkdrawable.h"
#include "gdkprivate.h"
+#include "gdkwindow.h"
+#include "gdkx.h"
#ifndef G_PI
#define G_PI 3.14159265358979323846
#endif
+/* Manipulation of drawables
+ */
+void
+gdk_drawable_set_data (GdkDrawable *drawable,
+ const gchar *key,
+ gpointer data,
+ GDestroyNotify destroy_func)
+{
+ g_dataset_set_data_full (drawable, key, data, destroy_func);
+}
+
+void
+gdk_drawable_get_data (GdkDrawable *drawable,
+ const gchar *key)
+{
+ g_dataset_get_data (drawable, key);
+}
+
+GdkDrawableType
+gdk_drawable_get_type (GdkDrawable *drawable)
+{
+ g_return_val_if_fail (drawable != NULL, (GdkDrawableType) -1);
+
+ return GDK_DRAWABLE_TYPE (drawable);
+}
+
+void
+gdk_drawable_get_size (GdkDrawable *drawable,
+ gint *width,
+ gint *height)
+{
+ GdkDrawablePrivate *drawable_private;
+
+ g_return_if_fail (drawable != NULL);
+
+ drawable_private = (GdkDrawablePrivate*) drawable;
+
+ if (width)
+ *width = drawable_private->width;
+ if (height)
+ *height = drawable_private->height;
+}
+
+void
+gdk_drawable_set_colormap (GdkDrawable *drawable,
+ GdkColormap *colormap)
+{
+ GdkDrawablePrivate *drawable_private;
+ GdkColormapPrivate *colormap_private;
+
+ g_return_if_fail (drawable != NULL);
+ g_return_if_fail (colormap != NULL);
+
+ drawable_private = (GdkDrawablePrivate*) drawable;
+ colormap_private = (GdkColormapPrivate*) colormap;
+
+ if (!GDK_DRAWABLE_DESTROYED (drawable))
+ {
+ if (GDK_IS_WINDOW (drawable))
+ {
+ g_return_if_fail (colormap_private->visual !=
+ ((GdkColormapPrivate*)(drawable_private->colormap))->visual);
+ /* XXX ??? */
+ GDK_NOTE (MISC, g_print ("gdk_drawable_set_colormap: %#x %#x\n",
+ GDK_DRAWABLE_XID (drawable),
+ colormap_private->xcolormap));
+ }
+ if (drawable_private->colormap)
+ gdk_colormap_unref (drawable_private->colormap);
+ drawable_private->colormap = colormap;
+ gdk_colormap_ref (drawable_private->colormap);
+
+ if (GDK_IS_WINDOW (drawable) &&
+ drawable_private->window_type != GDK_WINDOW_TOPLEVEL)
+ gdk_window_add_colormap_windows (drawable);
+ }
+}
+
+GdkColormap*
+gdk_drawable_get_colormap (GdkDrawable *drawable)
+{
+ GdkDrawablePrivate *drawable_private;
+
+ g_return_val_if_fail (drawable != NULL, NULL);
+ drawable_private = (GdkDrawablePrivate*) drawable;
+
+ if (!GDK_DRAWABLE_DESTROYED (drawable))
+ {
+ if (drawable_private->colormap == NULL)
+ return gdk_colormap_get_system (); /* XXX ??? */
+ else
+ return drawable_private->colormap;
+ }
+
+ return NULL;
+}
+
+GdkVisual*
+gdk_drawable_get_visual (GdkDrawable *drawable)
+{
+ GdkColormap *colormap;
+
+ g_return_val_if_fail (drawable != NULL, NULL);
+
+ colormap = gdk_drawable_get_colormap (drawable);
+ return colormap ? gdk_colormap_get_visual (colormap) : NULL;
+}
+
void
gdk_draw_point (GdkDrawable *drawable,
GdkGC *gc,
gint x,
gint y)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkGCPrivate *gc_private;
HDC hdc;
g_return_if_fail (drawable != NULL);
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
hdc = gdk_gc_predraw (drawable_private, gc_private);
gint x2,
gint y2)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkGCPrivate *gc_private;
HDC hdc;
g_return_if_fail (drawable != NULL);
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
hdc = gdk_gc_predraw (drawable_private, gc_private);
gint width,
gint height)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkGCPrivate *gc_private;
HDC hdc;
HGDIOBJ oldpen, oldbrush;
g_return_if_fail (drawable != NULL);
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
if (width == -1)
gint angle1,
gint angle2)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkGCPrivate *gc_private;
HDC hdc;
int nXStartArc, nYStartArc, nXEndArc, nYEndArc;
g_return_if_fail (drawable != NULL);
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
if (width == -1)
GdkPoint *points,
gint npoints)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkGCPrivate *gc_private;
HDC hdc;
POINT *pts;
g_return_if_fail (drawable != NULL);
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
GDK_NOTE (MISC, g_print ("gdk_draw_polygon: %#x (%d) %d\n",
const gchar *text,
gint text_length)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkFontPrivate *font_private;
GdkGCPrivate *gc_private;
HDC hdc;
g_return_if_fail (gc != NULL);
g_return_if_fail (text != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
font_private = (GdkFontPrivate*) font;
const GdkWChar *text,
gint text_length)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkFontPrivate *font_private;
GdkGCPrivate *gc_private;
gint i;
g_return_if_fail (gc != NULL);
g_return_if_fail (text != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
font_private = (GdkFontPrivate*) font;
gint width,
gint height)
{
- GdkWindowPrivate *drawable_private;
- GdkWindowPrivate *src_private;
+ GdkDrawablePrivate *drawable_private;
+ GdkDrawablePrivate *src_private;
GdkGCPrivate *gc_private;
HDC hdc;
HDC srcdc;
g_return_if_fail (src != NULL);
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- src_private = (GdkWindowPrivate*) src;
- if (drawable_private->destroyed || src_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable) || GDK_DRAWABLE_DESTROYED (src))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
+ src_private = (GdkDrawablePrivate*) src;
gc_private = (GdkGCPrivate*) gc;
if (width == -1)
SetRectEmpty (&r);
outside_rgn = CreateRectRgnIndirect (&r);
- if (drawable_private->window_type != GDK_WINDOW_PIXMAP)
+ if (drawable_private->window_type != GDK_DRAWABLE_PIXMAP)
{
/* If we are drawing on a window, calculate the region that is
* outside the source pixmap, and invalidate that, causing it to
/* Strangely enough, this function is called also to bitblt
* from a window.
*/
- if (src_private->window_type == GDK_WINDOW_PIXMAP)
+ if (src_private->window_type == GDK_DRAWABLE_PIXMAP)
{
if ((srcdc = CreateCompatibleDC (hdc)) == NULL)
g_warning ("gdk_draw_pixmap: CreateCompatibleDC failed");
GdkPoint *points,
gint npoints)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkGCPrivate *gc_private;
HDC hdc;
int i;
g_return_if_fail ((points != NULL) && (npoints > 0));
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
hdc = gdk_gc_predraw (drawable_private, gc_private);
GdkSegment *segs,
gint nsegs)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkGCPrivate *gc_private;
HDC hdc;
int i;
g_return_if_fail (segs != NULL);
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
hdc = gdk_gc_predraw (drawable_private, gc_private);
GdkPoint *points,
gint npoints)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkGCPrivate *gc_private;
HDC hdc;
POINT *pts;
g_return_if_fail (points != NULL);
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
+ if (GDK_DRAWABLE_DESTROYED (drawable))
+ return;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
hdc = gdk_gc_predraw (drawable_private, gc_private);
*/
static guint button_number[2]; /* The last 2 buttons to be pressed.
*/
-static GdkWindowPrivate *p_grab_window = NULL; /* Window that currently
- * holds the pointer grab
- */
+static GdkWindow *p_grab_window = NULL; /* Window that currently
+ * holds the pointer grab
+ */
-static GdkWindowPrivate *k_grab_window = NULL; /* Window the holds the
- * keyboard grab
- */
+static GdkWindow *k_grab_window = NULL; /* Window the holds the
+ * keyboard grab
+ */
static GList *client_filters; /* Filters for client messages */
GdkCursor * cursor,
guint32 time)
{
- GdkWindowPrivate *window_private;
HWND xwindow;
HWND xconfine_to;
HCURSOR xcursor;
- GdkWindowPrivate *confine_to_private;
GdkCursorPrivate *cursor_private;
gint return_val;
g_return_val_if_fail (window != NULL, 0);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
+ g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
- window_private = (GdkWindowPrivate*) window;
- confine_to_private = (GdkWindowPrivate*) confine_to;
cursor_private = (GdkCursorPrivate*) cursor;
- xwindow = window_private->xwindow;
+ xwindow = GDK_DRAWABLE_XID (window);
- if (!confine_to || confine_to_private->destroyed)
+ if (!confine_to || GDK_DRAWABLE_DESTROYED (confine_to))
xconfine_to = NULL;
else
- xconfine_to = confine_to_private->xwindow;
+ xconfine_to = GDK_DRAWABLE_XID (confine_to);
if (!cursor)
xcursor = NULL;
if (return_val == Success)
{
- if (!window_private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
GDK_NOTE (EVENTS, g_print ("gdk_pointer_grab: %#x %s %#x\n",
xwindow,
if (return_val == GrabSuccess)
{
- p_grab_window = window_private;
+ p_grab_window = window;
p_grab_cursor = xcursor;
}
gint owner_events,
guint32 time)
{
- GdkWindowPrivate *window_private;
gint return_val;
g_return_val_if_fail (window != NULL, 0);
-
- window_private = (GdkWindowPrivate*) window;
+ g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
GDK_NOTE (EVENTS, g_print ("gdk_keyboard_grab %#x\n",
- window_private->xwindow));
+ GDK_DRAWABLE_XID (window)));
- if (!window_private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
k_grab_owner_events = owner_events != 0;
return_val = GrabSuccess;
return_val = AlreadyGrabbed;
if (return_val == GrabSuccess)
- k_grab_window = window_private;
+ k_grab_window = window;
return return_val;
}
MINMAXINFO *lpmmi;
GdkWindowPrivate *curWnd_private;
GdkEventMask mask;
+ GdkDrawablePrivate *pixmap_private;
+ HDC bgdc;
+ HGDIOBJ oldbitmap;
int button;
int i, j;
gchar buf[256];
event->any.window = window;
- if (window_private && window_private->destroyed)
+ if (window_private && GDK_DRAWABLE_DESTROYED (window))
{
}
else
event->selection.property = gdk_selection_property;
event->selection.time = xevent->time;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
/* Will pass through switch below without match */
}
event->selection.requestor = (guint32) xevent->hwnd;
event->selection.time = xevent->time;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
/* Again, will pass through switch below without match */
}
event->selection.selection = xevent->wParam;
event->selection.time = xevent->time;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
/* Once again, we will pass through switch below without match */
}
ignore_WM_CHAR = TRUE;
keyup_or_down:
- if (k_grab_window != NULL
- && !k_grab_owner_events)
+ if (k_grab_window != NULL && !k_grab_owner_events)
{
/* Keyboard is grabbed with owner_events FALSE */
GDK_NOTE (EVENTS,
g_print ("...grabbed, owner_events FALSE, "
- "sending to %#x\n", k_grab_window->xwindow));
- event->key.window = (GdkWindow *) k_grab_window;
+ "sending to %#x\n",
+ GDK_DRAWABLE_XID (k_grab_window)));
+ event->key.window = k_grab_window;
}
else if (window_private
&& (((xevent->message == WM_KEYUP
&& !(window_private->event_mask & GDK_KEY_PRESS_MASK))))
{
/* Owner window doesn't want it */
- if (k_grab_window != NULL
- && k_grab_owner_events)
+ if (k_grab_window != NULL && k_grab_owner_events)
{
/* Keyboard is grabbed with owner_events TRUE */
GDK_NOTE (EVENTS,
g_print ("...grabbed, owner_events TRUE, doesn't want it, "
- "sending to %#x\n", k_grab_window->xwindow));
- event->key.window = (GdkWindow *) k_grab_window;
+ "sending to %#x\n",
+ GDK_DRAWABLE_XID (k_grab_window)));
+ event->key.window = k_grab_window;
}
else
{
gdk_window_ref (window);
window_private = (GdkWindowPrivate *) window;
GDK_NOTE (EVENTS, g_print ("...propagating to %#x\n",
- window_private->xwindow));
+ GDK_DRAWABLE_XID (window)));
goto keyup_or_down;
}
}
event->key.state |= GDK_CONTROL_MASK;
if (xevent->wParam != VK_MENU && GetKeyState (VK_MENU) < 0)
event->key.state |= GDK_MOD1_MASK;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
event->key.string = NULL;
event->key.length = 0;
break;
* wants key presses but still wants releases to be propagated,
* for instance.
*/
- if (k_grab_window != NULL
- && !k_grab_owner_events)
+ if (k_grab_window != NULL && !k_grab_owner_events)
{
/* Keyboard is grabbed with owner_events FALSE */
GDK_NOTE (EVENTS,
g_print ("...grabbed, owner_events FALSE, "
- "sending to %#x\n", k_grab_window->xwindow));
- event->key.window = (GdkWindow *) k_grab_window;
+ "sending to %#x\n",
+ GDK_DRAWABLE_XID (k_grab_window)));
+ event->key.window = k_grab_window;
}
else if (window_private
&& !(window_private->event_mask & (GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK)))
{
/* Owner window doesn't want it */
- if (k_grab_window != NULL
- && k_grab_owner_events)
+ if (k_grab_window != NULL && k_grab_owner_events)
{
/* Keyboard is grabbed with owner_events TRUE */
GDK_NOTE (EVENTS,
g_print ("...grabbed, owner_events TRUE, doesn't want it, "
- "sending to %#x\n", k_grab_window->xwindow));
- event->key.window = (GdkWindow *) k_grab_window;
+ "sending to %#x\n",
+ GDK_DRAWABLE_XID (k_grab_window)));
+ event->key.window = k_grab_window;
}
else
{
gdk_window_ref (window);
window_private = (GdkWindowPrivate *) window;
GDK_NOTE (EVENTS, g_print ("...propagating to %#x\n",
- window_private->xwindow));
+ GDK_DRAWABLE_XID (window)));
goto wm_char;
}
}
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
if (return_val && (window_private->event_mask & GDK_KEY_RELEASE_MASK))
{
/* Return the release event, and maybe append the press
else
mask = 0; /* ??? */
- if (p_grab_window != NULL
- && !p_grab_owner_events)
+ if (p_grab_window != NULL && !p_grab_owner_events)
{
/* Pointer is grabbed with owner_events FALSE */
GDK_NOTE (EVENTS, g_print ("...grabbed, owner_events FALSE\n"));
/* Grabber doesn't want it */
break;
else
- event->button.window = (GdkWindow *) p_grab_window;
+ event->button.window = p_grab_window;
GDK_NOTE (EVENTS, g_print ("...sending to %#x\n",
- p_grab_window->xwindow));
+ GDK_DRAWABLE_XID (p_grab_window)));
}
else if (window_private
&& !(mask & GDK_BUTTON_PRESS_MASK))
{
/* Owner window doesn't want it */
- if (p_grab_window != NULL
- && p_grab_owner_events)
+ if (p_grab_window != NULL && p_grab_owner_events)
{
/* Pointer is grabbed wÃth owner_events TRUE */
GDK_NOTE (EVENTS, g_print ("...grabbed, owner_events TRUE, doesn't want it\n"));
/* Grabber doesn't want it either */
break;
else
- event->button.window = (GdkWindow *) p_grab_window;
+ event->button.window = p_grab_window;
GDK_NOTE (EVENTS, g_print ("...sending to %#x\n",
- p_grab_window->xwindow));
+ GDK_DRAWABLE_XID (p_grab_window)));
}
else
{
break;
pt.x = LOWORD (xevent->lParam);
pt.y = HIWORD (xevent->lParam);
- ClientToScreen (window_private->xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
gdk_window_unref (window);
window = window_private->parent;
gdk_window_ref (window);
window_private = (GdkWindowPrivate *) window;
- ScreenToClient (window_private->xwindow, &pt);
+ ScreenToClient (GDK_DRAWABLE_XID (window), &pt);
xevent->lParam = MAKELPARAM (pt.x, pt.y);
GDK_NOTE (EVENTS, g_print ("...propagating to %#x\n",
- window_private->xwindow));
+ GDK_DRAWABLE_XID (window)));
goto buttondown; /* What did Dijkstra say? */
}
}
button_number[1] = -1;
button_number[0] = event->button.button;
}
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
if (return_val
&& p_grab_window != NULL
- && event->any.window == (GdkWindow *) p_grab_window
- && p_grab_window != window_private)
+ && event->any.window == p_grab_window
+ && p_grab_window != window)
{
/* Translate coordinates to grabber */
pt.x = event->button.x;
pt.y = event->button.y;
- ClientToScreen (window_private->xwindow, &pt);
- ScreenToClient (p_grab_window->xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
+ ScreenToClient (GDK_DRAWABLE_XID (p_grab_window), &pt);
event->button.x = pt.x;
event->button.y = pt.y;
GDK_NOTE (EVENTS, g_print ("...new coords are +%d+%d\n", pt.x, pt.y));
else
mask = 0;
- if (p_grab_window != NULL
- && !p_grab_owner_events)
+ if (p_grab_window != NULL && !p_grab_owner_events)
{
/* Pointer is grabbed with owner_events FALSE */
GDK_NOTE (EVENTS, g_print ("...grabbed, owner_events FALSE\n"));
/* Grabber doesn't want it */
break;
else
- event->button.window = (GdkWindow *) p_grab_window;
+ event->button.window = p_grab_window;
GDK_NOTE (EVENTS, g_print ("...sending to %#x\n",
- p_grab_window->xwindow));
+ GDK_DRAWABLE_XID (p_grab_window)));
}
else if (window_private
&& !(mask & GDK_BUTTON_RELEASE_MASK))
{
/* Owner window doesn't want it */
- if (p_grab_window != NULL
- && p_grab_owner_events)
+ if (p_grab_window != NULL && p_grab_owner_events)
{
/* Pointer is grabbed wÃth owner_events TRUE */
GDK_NOTE (EVENTS, g_print ("...grabbed, owner_events TRUE, doesn't want it\n"));
/* Grabber doesn't want it */
break;
else
- event->button.window = (GdkWindow *) p_grab_window;
+ event->button.window = p_grab_window;
GDK_NOTE (EVENTS, g_print ("...sending to %#x\n",
- p_grab_window->xwindow));
+ GDK_DRAWABLE_XID (p_grab_window)));
}
else
{
break;
pt.x = LOWORD (xevent->lParam);
pt.y = HIWORD (xevent->lParam);
- ClientToScreen (window_private->xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
gdk_window_unref (window);
window = window_private->parent;
gdk_window_ref (window);
window_private = (GdkWindowPrivate *) window;
- ScreenToClient (window_private->xwindow, &pt);
+ ScreenToClient (GDK_DRAWABLE_XID (window), &pt);
xevent->lParam = MAKELPARAM (pt.x, pt.y);
GDK_NOTE (EVENTS, g_print ("...propagating to %#x\n",
- window_private->xwindow));
+ GDK_DRAWABLE_XID (window)));
goto buttonup;
}
}
event->button.button = button;
event->button.source = GDK_SOURCE_MOUSE;
event->button.deviceid = GDK_CORE_POINTER;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
if (return_val
&& p_grab_window != NULL
- && event->any.window == (GdkWindow *) p_grab_window
- && p_grab_window != window_private)
+ && event->any.window == p_grab_window
+ && p_grab_window != window)
{
/* Translate coordinates to grabber */
pt.x = event->button.x;
pt.y = event->button.y;
- ClientToScreen (window_private->xwindow, &pt);
- ScreenToClient (p_grab_window->xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
+ ScreenToClient (GDK_DRAWABLE_XID (p_grab_window), &pt);
event->button.x = pt.x;
event->button.y = pt.y;
GDK_NOTE (EVENTS, g_print ("...new coords are +%d+%d\n", pt.x, pt.y));
else
mask = 0;
- if (p_grab_window
- && !p_grab_owner_events)
+ if (p_grab_window && !p_grab_owner_events)
{
/* Pointer is grabbed with owner_events FALSE */
GDK_NOTE (EVENTS,
&& (mask & GDK_BUTTON3_MOTION_MASK))))
break;
else
- event->motion.window = (GdkWindow *) p_grab_window;
+ event->motion.window = p_grab_window;
GDK_NOTE (EVENTS, g_print ("...sending to %#x\n",
- p_grab_window->xwindow));
+ GDK_DRAWABLE_XID (p_grab_window)));
}
else if (window_private
&& !((mask & GDK_POINTER_MOTION_MASK)
&& (mask & GDK_BUTTON3_MOTION_MASK))))
{
/* Owner window doesn't want it */
- if (p_grab_window != NULL
- && p_grab_owner_events)
+ if (p_grab_window != NULL && p_grab_owner_events)
{
/* Pointer is grabbed wÃth owner_events TRUE */
GDK_NOTE (EVENTS, g_print ("...grabbed, owner_events TRUE, doesn't want it\n"));
/* Grabber doesn't want it either */
break;
else
- event->motion.window = (GdkWindow *) p_grab_window;
+ event->motion.window = p_grab_window;
GDK_NOTE (EVENTS, g_print ("...sending to %#x\n",
- p_grab_window->xwindow));
+ GDK_DRAWABLE_XID (p_grab_window)));
}
else
{
break;
pt.x = LOWORD (xevent->lParam);
pt.y = HIWORD (xevent->lParam);
- ClientToScreen (window_private->xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
gdk_window_unref (window);
window = window_private->parent;
gdk_window_ref (window);
window_private = (GdkWindowPrivate *) window;
- ScreenToClient (window_private->xwindow, &pt);
+ ScreenToClient (GDK_DRAWABLE_XID (window), &pt);
xevent->lParam = MAKELPARAM (pt.x, pt.y);
GDK_NOTE (EVENTS, g_print ("...propagating to %#x\n",
- window_private->xwindow));
+ GDK_DRAWABLE_XID (window)));
goto mousemotion;
}
}
event->motion.source = GDK_SOURCE_MOUSE;
event->motion.deviceid = GDK_CORE_POINTER;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
if (return_val
&& p_grab_window != NULL
- && event->any.window == (GdkWindow *) p_grab_window
- && p_grab_window != window_private)
+ && event->any.window == p_grab_window
+ && p_grab_window != window)
{
/* Translate coordinates to grabber */
pt.x = event->motion.x;
pt.y = event->motion.y;
- ClientToScreen (window_private->xwindow, &pt);
- ScreenToClient (p_grab_window->xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
+ ScreenToClient (GDK_DRAWABLE_XID (p_grab_window), &pt);
event->motion.x = pt.x;
event->motion.y = pt.y;
GDK_NOTE (EVENTS, g_print ("...new coords are +%d+%d\n", pt.x, pt.y));
event->focus_change.type = GDK_FOCUS_CHANGE;
event->focus_change.window = window;
event->focus_change.in = (xevent->message == WM_SETFOCUS);
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
break;
#if 0
case WM_ACTIVATE:
GDK_NOTE (EVENTS, g_print ("WM_ERASEBKGND: %#x dc %#x\n",
xevent->hwnd, xevent->wParam));
- if (!window_private || window_private->destroyed)
+ if (!window_private || GDK_DRAWABLE_DESTROYED (window))
break;
- colormap_private = (GdkColormapPrivate *) window_private->colormap;
+ colormap_private = (GdkColormapPrivate *) window_private->drawable.colormap;
hdc = (HDC) xevent->wParam;
if (colormap_private
&& colormap_private->xcolormap->rc_palette)
}
else if (window_private->bg_type == GDK_WIN32_BG_PIXMAP)
{
- GdkPixmapPrivate *pixmap_private;
- HDC bgdc;
- HGDIOBJ oldbitmap;
-
- pixmap_private = (GdkPixmapPrivate *) window_private->bg_pixmap;
+ pixmap_private = (GdkDrawablePrivate*) window_private->bg_pixmap;
GetClipBox (hdc, &rect);
if (pixmap_private->width <= 8
event->expose.area.height = paintstruct.rcPaint.bottom - paintstruct.rcPaint.top;
event->expose.count = 0;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
if (return_val)
{
GList *list = queued_events;
SetCursor (p_grab_cursor);
}
else if (window_private
- && !window_private->destroyed
+ && !GDK_DRAWABLE_DESTROYED (window)
&& window_private->xcursor)
{
GDK_NOTE (EVENTS, g_print ("...SetCursor(%#x)\n",
event->any.type = GDK_MAP;
event->any.window = window;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
break;
#endif
event->any.window = window;
if (event->any.type == GDK_UNMAP
- && p_grab_window == window_private)
+ && p_grab_window == window)
gdk_pointer_ungrab (xevent->time);
if (event->any.type == GDK_UNMAP
- && k_grab_window == window_private)
+ && k_grab_window == window)
gdk_keyboard_ungrab (xevent->time);
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
break;
#endif
case WM_SIZE:
event->any.type = GDK_UNMAP;
event->any.window = window;
- if (p_grab_window == window_private)
+ if (p_grab_window == window)
gdk_pointer_ungrab (xevent->time);
- if (k_grab_window == window_private)
+ if (k_grab_window == window)
gdk_keyboard_ungrab (xevent->time);
- return_val = !window_private->destroyed;
+ return_val = !GDK_DRAWABLE_DESTROYED (window);
#endif
}
else if (window_private != NULL
&& (xevent->wParam == SIZE_RESTORED
|| xevent->wParam == SIZE_MAXIMIZED)
#if 1
- && window_private->window_type != GDK_WINDOW_CHILD
+ && GDK_DRAWABLE_TYPE (window) != GDK_WINDOW_CHILD
#endif
)
{
event->configure.height = HIWORD (xevent->lParam);
window_private->x = event->configure.x;
window_private->y = event->configure.y;
- window_private->width = event->configure.width;
- window_private->height = event->configure.height;
+ window_private->drawable.width = event->configure.width;
+ window_private->drawable.height = event->configure.height;
if (window_private->resize_count > 1)
window_private->resize_count -= 1;
- return_val = !window_private->destroyed;
+ return_val = !GDK_DRAWABLE_DESTROYED (window);
if (return_val
&& window_private->extension_events != 0
&& gdk_input_vtable.configure_event)
&& !(window_private->event_mask & GDK_STRUCTURE_MASK))
break;
if (window_private != NULL
- && window_private->window_type != GDK_WINDOW_CHILD)
+ && GDK_DRAWABLE_TYPE (window) != GDK_WINDOW_CHILD)
{
event->configure.type = GDK_CONFIGURE;
event->configure.window = window;
event->configure.height = rect.bottom;
window_private->x = event->configure.x;
window_private->y = event->configure.y;
- window_private->width = event->configure.width;
- window_private->height = event->configure.height;
+ window_private->drawable.width = event->configure.width;
+ window_private->drawable.height = event->configure.height;
- return_val = !window_private->destroyed;
+ return_val = !GDK_DRAWABLE_DESTROYED (window);
}
break;
event->any.type = GDK_DELETE;
event->any.window = window;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
break;
#if 0
event->selection.property = gdk_selection_property;
event->selection.requestor = (guint32) xevent->hwnd;
event->selection.time = xevent->time;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
#else
/* Test code, to see if SetClipboardData works when called from
* the window procedure.
curWnd = NULL;
}
- if (p_grab_window == window_private)
+ if (p_grab_window == window)
gdk_pointer_ungrab (xevent->time);
- if (k_grab_window == window_private)
+ if (k_grab_window == window)
gdk_keyboard_ungrab (xevent->time);
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
break;
#ifdef HAVE_WINTAB
*/
static guint button_number[2]; /* The last 2 buttons to be pressed.
*/
-static GdkWindowPrivate *p_grab_window = NULL; /* Window that currently
- * holds the pointer grab
- */
+static GdkWindow *p_grab_window = NULL; /* Window that currently
+ * holds the pointer grab
+ */
-static GdkWindowPrivate *k_grab_window = NULL; /* Window the holds the
- * keyboard grab
- */
+static GdkWindow *k_grab_window = NULL; /* Window the holds the
+ * keyboard grab
+ */
static GList *client_filters; /* Filters for client messages */
GdkCursor * cursor,
guint32 time)
{
- GdkWindowPrivate *window_private;
HWND xwindow;
HWND xconfine_to;
HCURSOR xcursor;
- GdkWindowPrivate *confine_to_private;
GdkCursorPrivate *cursor_private;
gint return_val;
g_return_val_if_fail (window != NULL, 0);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
+ g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
- window_private = (GdkWindowPrivate*) window;
- confine_to_private = (GdkWindowPrivate*) confine_to;
cursor_private = (GdkCursorPrivate*) cursor;
- xwindow = window_private->xwindow;
+ xwindow = GDK_DRAWABLE_XID (window);
- if (!confine_to || confine_to_private->destroyed)
+ if (!confine_to || GDK_DRAWABLE_DESTROYED (confine_to))
xconfine_to = NULL;
else
- xconfine_to = confine_to_private->xwindow;
+ xconfine_to = GDK_DRAWABLE_XID (confine_to);
if (!cursor)
xcursor = NULL;
if (return_val == Success)
{
- if (!window_private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
GDK_NOTE (EVENTS, g_print ("gdk_pointer_grab: %#x %s %#x\n",
xwindow,
if (return_val == GrabSuccess)
{
- p_grab_window = window_private;
+ p_grab_window = window;
p_grab_cursor = xcursor;
}
gint owner_events,
guint32 time)
{
- GdkWindowPrivate *window_private;
gint return_val;
g_return_val_if_fail (window != NULL, 0);
-
- window_private = (GdkWindowPrivate*) window;
+ g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
GDK_NOTE (EVENTS, g_print ("gdk_keyboard_grab %#x\n",
- window_private->xwindow));
+ GDK_DRAWABLE_XID (window)));
- if (!window_private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
k_grab_owner_events = owner_events != 0;
return_val = GrabSuccess;
return_val = AlreadyGrabbed;
if (return_val == GrabSuccess)
- k_grab_window = window_private;
+ k_grab_window = window;
return return_val;
}
MINMAXINFO *lpmmi;
GdkWindowPrivate *curWnd_private;
GdkEventMask mask;
+ GdkDrawablePrivate *pixmap_private;
+ HDC bgdc;
+ HGDIOBJ oldbitmap;
int button;
int i, j;
gchar buf[256];
event->any.window = window;
- if (window_private && window_private->destroyed)
+ if (window_private && GDK_DRAWABLE_DESTROYED (window))
{
}
else
event->selection.property = gdk_selection_property;
event->selection.time = xevent->time;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
/* Will pass through switch below without match */
}
event->selection.requestor = (guint32) xevent->hwnd;
event->selection.time = xevent->time;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
/* Again, will pass through switch below without match */
}
event->selection.selection = xevent->wParam;
event->selection.time = xevent->time;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
/* Once again, we will pass through switch below without match */
}
ignore_WM_CHAR = TRUE;
keyup_or_down:
- if (k_grab_window != NULL
- && !k_grab_owner_events)
+ if (k_grab_window != NULL && !k_grab_owner_events)
{
/* Keyboard is grabbed with owner_events FALSE */
GDK_NOTE (EVENTS,
g_print ("...grabbed, owner_events FALSE, "
- "sending to %#x\n", k_grab_window->xwindow));
- event->key.window = (GdkWindow *) k_grab_window;
+ "sending to %#x\n",
+ GDK_DRAWABLE_XID (k_grab_window)));
+ event->key.window = k_grab_window;
}
else if (window_private
&& (((xevent->message == WM_KEYUP
&& !(window_private->event_mask & GDK_KEY_PRESS_MASK))))
{
/* Owner window doesn't want it */
- if (k_grab_window != NULL
- && k_grab_owner_events)
+ if (k_grab_window != NULL && k_grab_owner_events)
{
/* Keyboard is grabbed with owner_events TRUE */
GDK_NOTE (EVENTS,
g_print ("...grabbed, owner_events TRUE, doesn't want it, "
- "sending to %#x\n", k_grab_window->xwindow));
- event->key.window = (GdkWindow *) k_grab_window;
+ "sending to %#x\n",
+ GDK_DRAWABLE_XID (k_grab_window)));
+ event->key.window = k_grab_window;
}
else
{
gdk_window_ref (window);
window_private = (GdkWindowPrivate *) window;
GDK_NOTE (EVENTS, g_print ("...propagating to %#x\n",
- window_private->xwindow));
+ GDK_DRAWABLE_XID (window)));
goto keyup_or_down;
}
}
event->key.state |= GDK_CONTROL_MASK;
if (xevent->wParam != VK_MENU && GetKeyState (VK_MENU) < 0)
event->key.state |= GDK_MOD1_MASK;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
event->key.string = NULL;
event->key.length = 0;
break;
* wants key presses but still wants releases to be propagated,
* for instance.
*/
- if (k_grab_window != NULL
- && !k_grab_owner_events)
+ if (k_grab_window != NULL && !k_grab_owner_events)
{
/* Keyboard is grabbed with owner_events FALSE */
GDK_NOTE (EVENTS,
g_print ("...grabbed, owner_events FALSE, "
- "sending to %#x\n", k_grab_window->xwindow));
- event->key.window = (GdkWindow *) k_grab_window;
+ "sending to %#x\n",
+ GDK_DRAWABLE_XID (k_grab_window)));
+ event->key.window = k_grab_window;
}
else if (window_private
&& !(window_private->event_mask & (GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK)))
{
/* Owner window doesn't want it */
- if (k_grab_window != NULL
- && k_grab_owner_events)
+ if (k_grab_window != NULL && k_grab_owner_events)
{
/* Keyboard is grabbed with owner_events TRUE */
GDK_NOTE (EVENTS,
g_print ("...grabbed, owner_events TRUE, doesn't want it, "
- "sending to %#x\n", k_grab_window->xwindow));
- event->key.window = (GdkWindow *) k_grab_window;
+ "sending to %#x\n",
+ GDK_DRAWABLE_XID (k_grab_window)));
+ event->key.window = k_grab_window;
}
else
{
gdk_window_ref (window);
window_private = (GdkWindowPrivate *) window;
GDK_NOTE (EVENTS, g_print ("...propagating to %#x\n",
- window_private->xwindow));
+ GDK_DRAWABLE_XID (window)));
goto wm_char;
}
}
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
if (return_val && (window_private->event_mask & GDK_KEY_RELEASE_MASK))
{
/* Return the release event, and maybe append the press
else
mask = 0; /* ??? */
- if (p_grab_window != NULL
- && !p_grab_owner_events)
+ if (p_grab_window != NULL && !p_grab_owner_events)
{
/* Pointer is grabbed with owner_events FALSE */
GDK_NOTE (EVENTS, g_print ("...grabbed, owner_events FALSE\n"));
/* Grabber doesn't want it */
break;
else
- event->button.window = (GdkWindow *) p_grab_window;
+ event->button.window = p_grab_window;
GDK_NOTE (EVENTS, g_print ("...sending to %#x\n",
- p_grab_window->xwindow));
+ GDK_DRAWABLE_XID (p_grab_window)));
}
else if (window_private
&& !(mask & GDK_BUTTON_PRESS_MASK))
{
/* Owner window doesn't want it */
- if (p_grab_window != NULL
- && p_grab_owner_events)
+ if (p_grab_window != NULL && p_grab_owner_events)
{
/* Pointer is grabbed wÃth owner_events TRUE */
GDK_NOTE (EVENTS, g_print ("...grabbed, owner_events TRUE, doesn't want it\n"));
/* Grabber doesn't want it either */
break;
else
- event->button.window = (GdkWindow *) p_grab_window;
+ event->button.window = p_grab_window;
GDK_NOTE (EVENTS, g_print ("...sending to %#x\n",
- p_grab_window->xwindow));
+ GDK_DRAWABLE_XID (p_grab_window)));
}
else
{
break;
pt.x = LOWORD (xevent->lParam);
pt.y = HIWORD (xevent->lParam);
- ClientToScreen (window_private->xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
gdk_window_unref (window);
window = window_private->parent;
gdk_window_ref (window);
window_private = (GdkWindowPrivate *) window;
- ScreenToClient (window_private->xwindow, &pt);
+ ScreenToClient (GDK_DRAWABLE_XID (window), &pt);
xevent->lParam = MAKELPARAM (pt.x, pt.y);
GDK_NOTE (EVENTS, g_print ("...propagating to %#x\n",
- window_private->xwindow));
+ GDK_DRAWABLE_XID (window)));
goto buttondown; /* What did Dijkstra say? */
}
}
button_number[1] = -1;
button_number[0] = event->button.button;
}
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
if (return_val
&& p_grab_window != NULL
- && event->any.window == (GdkWindow *) p_grab_window
- && p_grab_window != window_private)
+ && event->any.window == p_grab_window
+ && p_grab_window != window)
{
/* Translate coordinates to grabber */
pt.x = event->button.x;
pt.y = event->button.y;
- ClientToScreen (window_private->xwindow, &pt);
- ScreenToClient (p_grab_window->xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
+ ScreenToClient (GDK_DRAWABLE_XID (p_grab_window), &pt);
event->button.x = pt.x;
event->button.y = pt.y;
GDK_NOTE (EVENTS, g_print ("...new coords are +%d+%d\n", pt.x, pt.y));
else
mask = 0;
- if (p_grab_window != NULL
- && !p_grab_owner_events)
+ if (p_grab_window != NULL && !p_grab_owner_events)
{
/* Pointer is grabbed with owner_events FALSE */
GDK_NOTE (EVENTS, g_print ("...grabbed, owner_events FALSE\n"));
/* Grabber doesn't want it */
break;
else
- event->button.window = (GdkWindow *) p_grab_window;
+ event->button.window = p_grab_window;
GDK_NOTE (EVENTS, g_print ("...sending to %#x\n",
- p_grab_window->xwindow));
+ GDK_DRAWABLE_XID (p_grab_window)));
}
else if (window_private
&& !(mask & GDK_BUTTON_RELEASE_MASK))
{
/* Owner window doesn't want it */
- if (p_grab_window != NULL
- && p_grab_owner_events)
+ if (p_grab_window != NULL && p_grab_owner_events)
{
/* Pointer is grabbed wÃth owner_events TRUE */
GDK_NOTE (EVENTS, g_print ("...grabbed, owner_events TRUE, doesn't want it\n"));
/* Grabber doesn't want it */
break;
else
- event->button.window = (GdkWindow *) p_grab_window;
+ event->button.window = p_grab_window;
GDK_NOTE (EVENTS, g_print ("...sending to %#x\n",
- p_grab_window->xwindow));
+ GDK_DRAWABLE_XID (p_grab_window)));
}
else
{
break;
pt.x = LOWORD (xevent->lParam);
pt.y = HIWORD (xevent->lParam);
- ClientToScreen (window_private->xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
gdk_window_unref (window);
window = window_private->parent;
gdk_window_ref (window);
window_private = (GdkWindowPrivate *) window;
- ScreenToClient (window_private->xwindow, &pt);
+ ScreenToClient (GDK_DRAWABLE_XID (window), &pt);
xevent->lParam = MAKELPARAM (pt.x, pt.y);
GDK_NOTE (EVENTS, g_print ("...propagating to %#x\n",
- window_private->xwindow));
+ GDK_DRAWABLE_XID (window)));
goto buttonup;
}
}
event->button.button = button;
event->button.source = GDK_SOURCE_MOUSE;
event->button.deviceid = GDK_CORE_POINTER;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
if (return_val
&& p_grab_window != NULL
- && event->any.window == (GdkWindow *) p_grab_window
- && p_grab_window != window_private)
+ && event->any.window == p_grab_window
+ && p_grab_window != window)
{
/* Translate coordinates to grabber */
pt.x = event->button.x;
pt.y = event->button.y;
- ClientToScreen (window_private->xwindow, &pt);
- ScreenToClient (p_grab_window->xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
+ ScreenToClient (GDK_DRAWABLE_XID (p_grab_window), &pt);
event->button.x = pt.x;
event->button.y = pt.y;
GDK_NOTE (EVENTS, g_print ("...new coords are +%d+%d\n", pt.x, pt.y));
else
mask = 0;
- if (p_grab_window
- && !p_grab_owner_events)
+ if (p_grab_window && !p_grab_owner_events)
{
/* Pointer is grabbed with owner_events FALSE */
GDK_NOTE (EVENTS,
&& (mask & GDK_BUTTON3_MOTION_MASK))))
break;
else
- event->motion.window = (GdkWindow *) p_grab_window;
+ event->motion.window = p_grab_window;
GDK_NOTE (EVENTS, g_print ("...sending to %#x\n",
- p_grab_window->xwindow));
+ GDK_DRAWABLE_XID (p_grab_window)));
}
else if (window_private
&& !((mask & GDK_POINTER_MOTION_MASK)
&& (mask & GDK_BUTTON3_MOTION_MASK))))
{
/* Owner window doesn't want it */
- if (p_grab_window != NULL
- && p_grab_owner_events)
+ if (p_grab_window != NULL && p_grab_owner_events)
{
/* Pointer is grabbed wÃth owner_events TRUE */
GDK_NOTE (EVENTS, g_print ("...grabbed, owner_events TRUE, doesn't want it\n"));
/* Grabber doesn't want it either */
break;
else
- event->motion.window = (GdkWindow *) p_grab_window;
+ event->motion.window = p_grab_window;
GDK_NOTE (EVENTS, g_print ("...sending to %#x\n",
- p_grab_window->xwindow));
+ GDK_DRAWABLE_XID (p_grab_window)));
}
else
{
break;
pt.x = LOWORD (xevent->lParam);
pt.y = HIWORD (xevent->lParam);
- ClientToScreen (window_private->xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
gdk_window_unref (window);
window = window_private->parent;
gdk_window_ref (window);
window_private = (GdkWindowPrivate *) window;
- ScreenToClient (window_private->xwindow, &pt);
+ ScreenToClient (GDK_DRAWABLE_XID (window), &pt);
xevent->lParam = MAKELPARAM (pt.x, pt.y);
GDK_NOTE (EVENTS, g_print ("...propagating to %#x\n",
- window_private->xwindow));
+ GDK_DRAWABLE_XID (window)));
goto mousemotion;
}
}
event->motion.source = GDK_SOURCE_MOUSE;
event->motion.deviceid = GDK_CORE_POINTER;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
if (return_val
&& p_grab_window != NULL
- && event->any.window == (GdkWindow *) p_grab_window
- && p_grab_window != window_private)
+ && event->any.window == p_grab_window
+ && p_grab_window != window)
{
/* Translate coordinates to grabber */
pt.x = event->motion.x;
pt.y = event->motion.y;
- ClientToScreen (window_private->xwindow, &pt);
- ScreenToClient (p_grab_window->xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
+ ScreenToClient (GDK_DRAWABLE_XID (p_grab_window), &pt);
event->motion.x = pt.x;
event->motion.y = pt.y;
GDK_NOTE (EVENTS, g_print ("...new coords are +%d+%d\n", pt.x, pt.y));
event->focus_change.type = GDK_FOCUS_CHANGE;
event->focus_change.window = window;
event->focus_change.in = (xevent->message == WM_SETFOCUS);
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
break;
#if 0
case WM_ACTIVATE:
GDK_NOTE (EVENTS, g_print ("WM_ERASEBKGND: %#x dc %#x\n",
xevent->hwnd, xevent->wParam));
- if (!window_private || window_private->destroyed)
+ if (!window_private || GDK_DRAWABLE_DESTROYED (window))
break;
- colormap_private = (GdkColormapPrivate *) window_private->colormap;
+ colormap_private = (GdkColormapPrivate *) window_private->drawable.colormap;
hdc = (HDC) xevent->wParam;
if (colormap_private
&& colormap_private->xcolormap->rc_palette)
}
else if (window_private->bg_type == GDK_WIN32_BG_PIXMAP)
{
- GdkPixmapPrivate *pixmap_private;
- HDC bgdc;
- HGDIOBJ oldbitmap;
-
- pixmap_private = (GdkPixmapPrivate *) window_private->bg_pixmap;
+ pixmap_private = (GdkDrawablePrivate*) window_private->bg_pixmap;
GetClipBox (hdc, &rect);
if (pixmap_private->width <= 8
event->expose.area.height = paintstruct.rcPaint.bottom - paintstruct.rcPaint.top;
event->expose.count = 0;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
if (return_val)
{
GList *list = queued_events;
SetCursor (p_grab_cursor);
}
else if (window_private
- && !window_private->destroyed
+ && !GDK_DRAWABLE_DESTROYED (window)
&& window_private->xcursor)
{
GDK_NOTE (EVENTS, g_print ("...SetCursor(%#x)\n",
event->any.type = GDK_MAP;
event->any.window = window;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
break;
#endif
event->any.window = window;
if (event->any.type == GDK_UNMAP
- && p_grab_window == window_private)
+ && p_grab_window == window)
gdk_pointer_ungrab (xevent->time);
if (event->any.type == GDK_UNMAP
- && k_grab_window == window_private)
+ && k_grab_window == window)
gdk_keyboard_ungrab (xevent->time);
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
break;
#endif
case WM_SIZE:
event->any.type = GDK_UNMAP;
event->any.window = window;
- if (p_grab_window == window_private)
+ if (p_grab_window == window)
gdk_pointer_ungrab (xevent->time);
- if (k_grab_window == window_private)
+ if (k_grab_window == window)
gdk_keyboard_ungrab (xevent->time);
- return_val = !window_private->destroyed;
+ return_val = !GDK_DRAWABLE_DESTROYED (window);
#endif
}
else if (window_private != NULL
&& (xevent->wParam == SIZE_RESTORED
|| xevent->wParam == SIZE_MAXIMIZED)
#if 1
- && window_private->window_type != GDK_WINDOW_CHILD
+ && GDK_DRAWABLE_TYPE (window) != GDK_WINDOW_CHILD
#endif
)
{
event->configure.height = HIWORD (xevent->lParam);
window_private->x = event->configure.x;
window_private->y = event->configure.y;
- window_private->width = event->configure.width;
- window_private->height = event->configure.height;
+ window_private->drawable.width = event->configure.width;
+ window_private->drawable.height = event->configure.height;
if (window_private->resize_count > 1)
window_private->resize_count -= 1;
- return_val = !window_private->destroyed;
+ return_val = !GDK_DRAWABLE_DESTROYED (window);
if (return_val
&& window_private->extension_events != 0
&& gdk_input_vtable.configure_event)
&& !(window_private->event_mask & GDK_STRUCTURE_MASK))
break;
if (window_private != NULL
- && window_private->window_type != GDK_WINDOW_CHILD)
+ && GDK_DRAWABLE_TYPE (window) != GDK_WINDOW_CHILD)
{
event->configure.type = GDK_CONFIGURE;
event->configure.window = window;
event->configure.height = rect.bottom;
window_private->x = event->configure.x;
window_private->y = event->configure.y;
- window_private->width = event->configure.width;
- window_private->height = event->configure.height;
+ window_private->drawable.width = event->configure.width;
+ window_private->drawable.height = event->configure.height;
- return_val = !window_private->destroyed;
+ return_val = !GDK_DRAWABLE_DESTROYED (window);
}
break;
event->any.type = GDK_DELETE;
event->any.window = window;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
break;
#if 0
event->selection.property = gdk_selection_property;
event->selection.requestor = (guint32) xevent->hwnd;
event->selection.time = xevent->time;
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
#else
/* Test code, to see if SetClipboardData works when called from
* the window procedure.
curWnd = NULL;
}
- if (p_grab_window == window_private)
+ if (p_grab_window == window)
gdk_pointer_ungrab (xevent->time);
- if (k_grab_window == window_private)
+ if (k_grab_window == window)
gdk_keyboard_ungrab (xevent->time);
- return_val = window_private && !window_private->destroyed;
+ return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
break;
#ifdef HAVE_WINTAB
*/
#include "config.h"
+
#include <string.h>
#include "gdkgc.h"
#include "gdkpixmap.h"
#include "gdkprivate.h"
+#include "gdkx.h"
GdkGC*
gdk_gc_new (GdkWindow *window)
GdkGCValues *values,
GdkGCValuesMask values_mask)
{
- GdkWindowPrivate *window_private;
GdkGC *gc;
GdkGCPrivate *private;
static GdkColor black;
g_return_val_if_fail (window != NULL, NULL);
- window_private = (GdkWindowPrivate*) window;
- if (window_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return NULL;
private = g_new (GdkGCPrivate, 1);
{
private->tile = values->tile;
gdk_pixmap_ref (private->tile);
- GDK_NOTE (MISC, g_print (" tile=%#x", ((GdkPixmapPrivate *)private->tile)->xwindow));
+ GDK_NOTE (MISC, g_print (" tile=%#x", GDK_DRAWABLE_XID (private->tile)));
}
else
private->tile = NULL;
{
private->stipple = values->stipple;
gdk_pixmap_ref (private->stipple);
- GDK_NOTE (MISC, g_print (" stipple=%#x", ((GdkPixmapPrivate *)private->stipple)->xwindow));
+ GDK_NOTE (MISC, g_print (" stipple=%#x", GDK_DRAWABLE_XID (private->stipple)));
}
else
private->stipple = NULL;
if (values_mask & GDK_GC_CLIP_MASK)
{
private->clip_region =
- BitmapToRegion (((GdkPixmapPrivate *)values->clip_mask)->xwindow);
+ BitmapToRegion ((HBITMAP) GDK_DRAWABLE_XID (values->clip_mask));
GDK_NOTE (MISC, g_print (" clip=%#x", private->clip_region));
}
else
if ((hdc = CreateCompatibleDC (NULL)) == NULL)
g_warning ("gdk_gc_get_values: CreateCompatibleDC failed");
if ((oldbitmap =
- SelectObject (hdc, ((GdkPixmapPrivate *) pixmap)->xwindow)) == NULL)
+ SelectObject (hdc, GDK_DRAWABLE_XID (pixmap))) == NULL)
g_warning ("gdk_gc_get_values: SelectObject #1 failed");
hbr = GetStockObject (BLACK_BRUSH);
if (!FillRect (hdc, &rect, hbr))
GdkPixmap *tile)
{
GdkGCPrivate *private;
- GdkPixmapPrivate *pixmap_private;
HBITMAP pixmap;
g_return_if_fail (gc != NULL);
pixmap = NULL;
if (tile)
- {
- pixmap_private = (GdkPixmapPrivate*) tile;
- pixmap = pixmap_private->xwindow;
- }
+ pixmap = GDK_DRAWABLE_XID (tile);
if (private->tile != NULL)
gdk_pixmap_unref (private->tile);
GdkPixmap *stipple)
{
GdkGCPrivate *private;
- GdkPixmapPrivate *pixmap_private;
HBITMAP pixmap;
g_return_if_fail (gc != NULL);
pixmap = NULL;
if (stipple)
- {
- pixmap_private = (GdkPixmapPrivate*) stipple;
- pixmap = pixmap_private->xwindow;
- }
+ pixmap = GDK_DRAWABLE_XID (stipple);
if (private->stipple != NULL)
gdk_pixmap_unref (private->stipple);
if (mask)
{
- GdkWindowPrivate *mask_private;
-
- mask_private = (GdkWindowPrivate*) mask;
- if (mask_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (mask))
return;
- xmask = mask_private->xwindow;
+ xmask = GDK_DRAWABLE_XID (mask);
}
else
xmask = NULL;
}
HDC
-gdk_gc_predraw (GdkWindowPrivate *window_private,
- GdkGCPrivate *gc_private)
+gdk_gc_predraw (GdkDrawablePrivate *drawable_private,
+ GdkGCPrivate *gc_private)
{
GdkColormapPrivate *colormap_private =
- (GdkColormapPrivate *) window_private->colormap;
+ (GdkColormapPrivate *) drawable_private->colormap;
COLORREF bg;
COLORREF fg;
LOGBRUSH logbrush;
g_assert (gc_private->xgc == NULL);
- if (window_private->window_type == GDK_WINDOW_PIXMAP)
+ if (drawable_private->window_type == GDK_DRAWABLE_PIXMAP)
{
if ((gc_private->xgc = CreateCompatibleDC (NULL)) == NULL)
g_warning ("gdk_gc_predraw: CreateCompatibleDC failed");
if ((gc_private->saved_dc = SaveDC (gc_private->xgc)) == 0)
g_warning ("gdk_gc_predraw: SaveDC #1 failed");
- if (SelectObject (gc_private->xgc, window_private->xwindow) == NULL)
+ if (SelectObject (gc_private->xgc, drawable_private->xwindow) == NULL)
g_warning ("gdk_gc_predraw: SelectObject #1 failed");
}
else
{
- if ((gc_private->xgc = GetDC (window_private->xwindow)) == NULL)
+ if ((gc_private->xgc = GetDC (drawable_private->xwindow)) == NULL)
g_warning ("gdk_gc_predraw: GetDC failed");
if ((gc_private->saved_dc = SaveDC (gc_private->xgc)) == 0)
g_warning ("gdk_gc_predraw: SaveDC #2 failed");
}
- gc_private->hwnd = window_private->xwindow;
+ gc_private->hwnd = drawable_private->xwindow;
if (colormap_private == NULL)
{
}
void
-gdk_gc_postdraw (GdkWindowPrivate *window_private,
- GdkGCPrivate *gc_private)
+gdk_gc_postdraw (GdkDrawablePrivate *drawable_private,
+ GdkGCPrivate *gc_private)
{
HGDIOBJ hpen;
HGDIOBJ hbr;
GdkColormapPrivate *colormap_private =
- (GdkColormapPrivate *) window_private->colormap;
+ (GdkColormapPrivate *) drawable_private->colormap;
if ((hpen = GetCurrentObject (gc_private->xgc, OBJ_PEN)) == NULL)
g_warning ("gdk_gc_postdraw: GetCurrentObject #1 failed");
g_warning ("gdk_gc_postraw: UnrealizeObject failed");
}
#endif
- if (window_private->window_type == GDK_WINDOW_PIXMAP)
+ if (drawable_private->window_type == GDK_DRAWABLE_PIXMAP)
{
if (!DeleteDC (gc_private->xgc))
g_warning ("gdk_gc_postdraw: DeleteDC failed");
*/
#include "config.h"
+
#include <string.h>
#include "gdkgc.h"
#include "gdkpixmap.h"
#include "gdkprivate.h"
+#include "gdkx.h"
GdkGC*
gdk_gc_new (GdkWindow *window)
GdkGCValues *values,
GdkGCValuesMask values_mask)
{
- GdkWindowPrivate *window_private;
GdkGC *gc;
GdkGCPrivate *private;
static GdkColor black;
g_return_val_if_fail (window != NULL, NULL);
- window_private = (GdkWindowPrivate*) window;
- if (window_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return NULL;
private = g_new (GdkGCPrivate, 1);
{
private->tile = values->tile;
gdk_pixmap_ref (private->tile);
- GDK_NOTE (MISC, g_print (" tile=%#x", ((GdkPixmapPrivate *)private->tile)->xwindow));
+ GDK_NOTE (MISC, g_print (" tile=%#x", GDK_DRAWABLE_XID (private->tile)));
}
else
private->tile = NULL;
{
private->stipple = values->stipple;
gdk_pixmap_ref (private->stipple);
- GDK_NOTE (MISC, g_print (" stipple=%#x", ((GdkPixmapPrivate *)private->stipple)->xwindow));
+ GDK_NOTE (MISC, g_print (" stipple=%#x", GDK_DRAWABLE_XID (private->stipple)));
}
else
private->stipple = NULL;
if (values_mask & GDK_GC_CLIP_MASK)
{
private->clip_region =
- BitmapToRegion (((GdkPixmapPrivate *)values->clip_mask)->xwindow);
+ BitmapToRegion ((HBITMAP) GDK_DRAWABLE_XID (values->clip_mask));
GDK_NOTE (MISC, g_print (" clip=%#x", private->clip_region));
}
else
if ((hdc = CreateCompatibleDC (NULL)) == NULL)
g_warning ("gdk_gc_get_values: CreateCompatibleDC failed");
if ((oldbitmap =
- SelectObject (hdc, ((GdkPixmapPrivate *) pixmap)->xwindow)) == NULL)
+ SelectObject (hdc, GDK_DRAWABLE_XID (pixmap))) == NULL)
g_warning ("gdk_gc_get_values: SelectObject #1 failed");
hbr = GetStockObject (BLACK_BRUSH);
if (!FillRect (hdc, &rect, hbr))
GdkPixmap *tile)
{
GdkGCPrivate *private;
- GdkPixmapPrivate *pixmap_private;
HBITMAP pixmap;
g_return_if_fail (gc != NULL);
pixmap = NULL;
if (tile)
- {
- pixmap_private = (GdkPixmapPrivate*) tile;
- pixmap = pixmap_private->xwindow;
- }
+ pixmap = GDK_DRAWABLE_XID (tile);
if (private->tile != NULL)
gdk_pixmap_unref (private->tile);
GdkPixmap *stipple)
{
GdkGCPrivate *private;
- GdkPixmapPrivate *pixmap_private;
HBITMAP pixmap;
g_return_if_fail (gc != NULL);
pixmap = NULL;
if (stipple)
- {
- pixmap_private = (GdkPixmapPrivate*) stipple;
- pixmap = pixmap_private->xwindow;
- }
+ pixmap = GDK_DRAWABLE_XID (stipple);
if (private->stipple != NULL)
gdk_pixmap_unref (private->stipple);
if (mask)
{
- GdkWindowPrivate *mask_private;
-
- mask_private = (GdkWindowPrivate*) mask;
- if (mask_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (mask))
return;
- xmask = mask_private->xwindow;
+ xmask = GDK_DRAWABLE_XID (mask);
}
else
xmask = NULL;
}
HDC
-gdk_gc_predraw (GdkWindowPrivate *window_private,
- GdkGCPrivate *gc_private)
+gdk_gc_predraw (GdkDrawablePrivate *drawable_private,
+ GdkGCPrivate *gc_private)
{
GdkColormapPrivate *colormap_private =
- (GdkColormapPrivate *) window_private->colormap;
+ (GdkColormapPrivate *) drawable_private->colormap;
COLORREF bg;
COLORREF fg;
LOGBRUSH logbrush;
g_assert (gc_private->xgc == NULL);
- if (window_private->window_type == GDK_WINDOW_PIXMAP)
+ if (drawable_private->window_type == GDK_DRAWABLE_PIXMAP)
{
if ((gc_private->xgc = CreateCompatibleDC (NULL)) == NULL)
g_warning ("gdk_gc_predraw: CreateCompatibleDC failed");
if ((gc_private->saved_dc = SaveDC (gc_private->xgc)) == 0)
g_warning ("gdk_gc_predraw: SaveDC #1 failed");
- if (SelectObject (gc_private->xgc, window_private->xwindow) == NULL)
+ if (SelectObject (gc_private->xgc, drawable_private->xwindow) == NULL)
g_warning ("gdk_gc_predraw: SelectObject #1 failed");
}
else
{
- if ((gc_private->xgc = GetDC (window_private->xwindow)) == NULL)
+ if ((gc_private->xgc = GetDC (drawable_private->xwindow)) == NULL)
g_warning ("gdk_gc_predraw: GetDC failed");
if ((gc_private->saved_dc = SaveDC (gc_private->xgc)) == 0)
g_warning ("gdk_gc_predraw: SaveDC #2 failed");
}
- gc_private->hwnd = window_private->xwindow;
+ gc_private->hwnd = drawable_private->xwindow;
if (colormap_private == NULL)
{
}
void
-gdk_gc_postdraw (GdkWindowPrivate *window_private,
- GdkGCPrivate *gc_private)
+gdk_gc_postdraw (GdkDrawablePrivate *drawable_private,
+ GdkGCPrivate *gc_private)
{
HGDIOBJ hpen;
HGDIOBJ hbr;
GdkColormapPrivate *colormap_private =
- (GdkColormapPrivate *) window_private->colormap;
+ (GdkColormapPrivate *) drawable_private->colormap;
if ((hpen = GetCurrentObject (gc_private->xgc, OBJ_PEN)) == NULL)
g_warning ("gdk_gc_postdraw: GetCurrentObject #1 failed");
g_warning ("gdk_gc_postraw: UnrealizeObject failed");
}
#endif
- if (window_private->window_type == GDK_WINDOW_PIXMAP)
+ if (drawable_private->window_type == GDK_DRAWABLE_PIXMAP)
{
if (!DeleteDC (gc_private->xgc))
g_warning ("gdk_gc_postdraw: DeleteDC failed");
#include "gdk.h" /* For gdk_error_trap_* / gdk_flush_* */
#include "gdkimage.h"
#include "gdkprivate.h"
+#include "gdkx.h"
static void gdk_image_put_normal (GdkDrawable *drawable,
GdkGC *gc,
{
GdkImage *image;
GdkImagePrivate *private;
- GdkWindowPrivate *win_private;
HDC hdc, memdc;
struct {
BITMAPINFOHEADER bmiHeader;
g_return_val_if_fail (window != NULL, NULL);
- win_private = (GdkWindowPrivate *) window;
- if (win_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return NULL;
GDK_NOTE (MISC, g_print ("gdk_image_get: %#x %dx%d@+%d+%d\n",
- win_private->xwindow, width, height, x, y));
+ GDK_DRAWABLE_XID (window), width, height, x, y));
private = g_new (GdkImagePrivate, 1);
image = (GdkImage*) private;
/* This function is called both to blit from a window and from
* a pixmap.
*/
- if (win_private->window_type == GDK_WINDOW_PIXMAP)
+ if (GDK_DRAWABLE_TYPE (window) == GDK_DRAWABLE_PIXMAP)
{
if ((hdc = CreateCompatibleDC (NULL)) == NULL)
{
g_free (image);
return NULL;
}
- if ((oldbitmap1 = SelectObject (hdc, win_private->xwindow)) == NULL)
+ if ((oldbitmap1 = SelectObject (hdc, GDK_DRAWABLE_XID (window))) == NULL)
{
g_warning ("gdk_image_get: SelectObject #1 failed");
DeleteDC (hdc);
g_free (image);
return NULL;
}
- GetObject (win_private->xwindow, sizeof (BITMAP), &bm);
+ GetObject (GDK_DRAWABLE_XID (window), sizeof (BITMAP), &bm);
GDK_NOTE (MISC,
g_print ("gdk_image_get: bmWidth = %d, bmHeight = %d, bmWidthBytes = %d, bmBitsPixel = %d\n",
bm.bmWidth, bm.bmHeight, bm.bmWidthBytes, bm.bmBitsPixel));
}
else
{
- if ((hdc = GetDC (win_private->xwindow)) == NULL)
+ if ((hdc = GetDC (GDK_DRAWABLE_XID (window))) == NULL)
{
g_warning ("gdk_image_get: GetDC failed");
g_free (image);
if ((memdc = CreateCompatibleDC (hdc)) == NULL)
{
g_warning ("gdk_image_get: CreateCompatibleDC #2 failed");
- if (win_private->window_type == GDK_WINDOW_PIXMAP)
+ if (GDK_DRAWABLE_TYPE (window) == GDK_DRAWABLE_PIXMAP)
{
SelectObject (hdc, oldbitmap1);
DeleteDC (hdc);
}
else
{
- ReleaseDC (win_private->xwindow, hdc);
+ ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
}
g_free (image);
return NULL;
{
g_warning ("gdk_image_get: CreateDIBSection failed");
DeleteDC (memdc);
- if (win_private->window_type == GDK_WINDOW_PIXMAP)
+ if (GDK_DRAWABLE_TYPE (window) == GDK_DRAWABLE_PIXMAP)
{
SelectObject (hdc, oldbitmap1);
DeleteDC (hdc);
}
else
{
- ReleaseDC (win_private->xwindow, hdc);
+ ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
}
g_free (image);
return NULL;
g_warning ("gdk_image_get: SelectObject #2 failed");
DeleteObject (private->ximage);
DeleteDC (memdc);
- if (win_private->window_type == GDK_WINDOW_PIXMAP)
+ if (GDK_DRAWABLE_TYPE (window) == GDK_DRAWABLE_PIXMAP)
{
SelectObject (hdc, oldbitmap1);
DeleteDC (hdc);
}
else
{
- ReleaseDC (win_private->xwindow, hdc);
+ ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
}
g_free (image);
return NULL;
SelectObject (memdc, oldbitmap2);
DeleteObject (private->ximage);
DeleteDC (memdc);
- if (win_private->window_type == GDK_WINDOW_PIXMAP)
+ if (GDK_DRAWABLE_TYPE (window) == GDK_DRAWABLE_PIXMAP)
{
SelectObject (hdc, oldbitmap1);
DeleteDC (hdc);
}
else
{
- ReleaseDC (win_private->xwindow, hdc);
+ ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
}
g_free (image);
return NULL;
if (!DeleteDC (memdc))
g_warning ("gdk_image_get: DeleteDC failed");
- if (win_private->window_type == GDK_WINDOW_PIXMAP)
+ if (GDK_DRAWABLE_TYPE (window) == GDK_DRAWABLE_PIXMAP)
{
SelectObject (hdc, oldbitmap1);
DeleteDC (hdc);
}
else
{
- ReleaseDC (win_private->xwindow, hdc);
+ ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
}
switch (image->depth)
gint width,
gint height)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkImagePrivate *image_private;
GdkGCPrivate *gc_private;
HDC hdc;
g_return_if_fail (image != NULL);
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
image_private = (GdkImagePrivate*) image;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
/* The image can in fact be "shared", so don't test */
#include "gdk.h" /* For gdk_error_trap_* / gdk_flush_* */
#include "gdkimage.h"
#include "gdkprivate.h"
+#include "gdkx.h"
static void gdk_image_put_normal (GdkDrawable *drawable,
GdkGC *gc,
{
GdkImage *image;
GdkImagePrivate *private;
- GdkWindowPrivate *win_private;
HDC hdc, memdc;
struct {
BITMAPINFOHEADER bmiHeader;
g_return_val_if_fail (window != NULL, NULL);
- win_private = (GdkWindowPrivate *) window;
- if (win_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return NULL;
GDK_NOTE (MISC, g_print ("gdk_image_get: %#x %dx%d@+%d+%d\n",
- win_private->xwindow, width, height, x, y));
+ GDK_DRAWABLE_XID (window), width, height, x, y));
private = g_new (GdkImagePrivate, 1);
image = (GdkImage*) private;
/* This function is called both to blit from a window and from
* a pixmap.
*/
- if (win_private->window_type == GDK_WINDOW_PIXMAP)
+ if (GDK_DRAWABLE_TYPE (window) == GDK_DRAWABLE_PIXMAP)
{
if ((hdc = CreateCompatibleDC (NULL)) == NULL)
{
g_free (image);
return NULL;
}
- if ((oldbitmap1 = SelectObject (hdc, win_private->xwindow)) == NULL)
+ if ((oldbitmap1 = SelectObject (hdc, GDK_DRAWABLE_XID (window))) == NULL)
{
g_warning ("gdk_image_get: SelectObject #1 failed");
DeleteDC (hdc);
g_free (image);
return NULL;
}
- GetObject (win_private->xwindow, sizeof (BITMAP), &bm);
+ GetObject (GDK_DRAWABLE_XID (window), sizeof (BITMAP), &bm);
GDK_NOTE (MISC,
g_print ("gdk_image_get: bmWidth = %d, bmHeight = %d, bmWidthBytes = %d, bmBitsPixel = %d\n",
bm.bmWidth, bm.bmHeight, bm.bmWidthBytes, bm.bmBitsPixel));
}
else
{
- if ((hdc = GetDC (win_private->xwindow)) == NULL)
+ if ((hdc = GetDC (GDK_DRAWABLE_XID (window))) == NULL)
{
g_warning ("gdk_image_get: GetDC failed");
g_free (image);
if ((memdc = CreateCompatibleDC (hdc)) == NULL)
{
g_warning ("gdk_image_get: CreateCompatibleDC #2 failed");
- if (win_private->window_type == GDK_WINDOW_PIXMAP)
+ if (GDK_DRAWABLE_TYPE (window) == GDK_DRAWABLE_PIXMAP)
{
SelectObject (hdc, oldbitmap1);
DeleteDC (hdc);
}
else
{
- ReleaseDC (win_private->xwindow, hdc);
+ ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
}
g_free (image);
return NULL;
{
g_warning ("gdk_image_get: CreateDIBSection failed");
DeleteDC (memdc);
- if (win_private->window_type == GDK_WINDOW_PIXMAP)
+ if (GDK_DRAWABLE_TYPE (window) == GDK_DRAWABLE_PIXMAP)
{
SelectObject (hdc, oldbitmap1);
DeleteDC (hdc);
}
else
{
- ReleaseDC (win_private->xwindow, hdc);
+ ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
}
g_free (image);
return NULL;
g_warning ("gdk_image_get: SelectObject #2 failed");
DeleteObject (private->ximage);
DeleteDC (memdc);
- if (win_private->window_type == GDK_WINDOW_PIXMAP)
+ if (GDK_DRAWABLE_TYPE (window) == GDK_DRAWABLE_PIXMAP)
{
SelectObject (hdc, oldbitmap1);
DeleteDC (hdc);
}
else
{
- ReleaseDC (win_private->xwindow, hdc);
+ ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
}
g_free (image);
return NULL;
SelectObject (memdc, oldbitmap2);
DeleteObject (private->ximage);
DeleteDC (memdc);
- if (win_private->window_type == GDK_WINDOW_PIXMAP)
+ if (GDK_DRAWABLE_TYPE (window) == GDK_DRAWABLE_PIXMAP)
{
SelectObject (hdc, oldbitmap1);
DeleteDC (hdc);
}
else
{
- ReleaseDC (win_private->xwindow, hdc);
+ ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
}
g_free (image);
return NULL;
if (!DeleteDC (memdc))
g_warning ("gdk_image_get: DeleteDC failed");
- if (win_private->window_type == GDK_WINDOW_PIXMAP)
+ if (GDK_DRAWABLE_TYPE (window) == GDK_DRAWABLE_PIXMAP)
{
SelectObject (hdc, oldbitmap1);
DeleteDC (hdc);
}
else
{
- ReleaseDC (win_private->xwindow, hdc);
+ ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
}
switch (image->depth)
gint width,
gint height)
{
- GdkWindowPrivate *drawable_private;
+ GdkDrawablePrivate *drawable_private;
GdkImagePrivate *image_private;
GdkGCPrivate *gc_private;
HDC hdc;
g_return_if_fail (image != NULL);
g_return_if_fail (gc != NULL);
- drawable_private = (GdkWindowPrivate*) drawable;
- if (drawable_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (drawable))
return;
image_private = (GdkImagePrivate*) image;
+ drawable_private = (GdkDrawablePrivate*) drawable;
gc_private = (GdkGCPrivate*) gc;
/* The image can in fact be "shared", so don't test */
#include "gdk.h"
#include "gdkinput.h"
#include "gdkprivate.h"
+#include "gdkx.h"
#ifdef HAVE_WINTAB
#include <wintab.h>
guint32 deviceid_counter = 0;
#ifdef HAVE_WINTAB
GdkDevicePrivate *gdkdev;
- GdkWindowPrivate *window_private;
+ GdkDrawablePrivate *window_private;
GdkWindowAttr wa;
WORD specversion;
LOGCONTEXT defcontext;
return;
}
gdk_window_ref (wintab_window);
- window_private = (GdkWindowPrivate *) wintab_window;
+ window_private = (GdkDrawablePrivate *) wintab_window;
for (devix = 0; devix < ndevices; devix++)
{
gdouble *xtilt,
gdouble *ytilt)
{
- GdkWindowPrivate *window_private;
+ GdkDrawablePrivate *window_private;
gint x_axis, y_axis, pressure_axis, xtilt_axis, ytilt_axis;
gdouble device_width, device_height;
gdouble x_offset, y_offset, x_scale, y_scale;
- window_private = (GdkWindowPrivate *) input_window->window;
+ window_private = (GdkDrawablePrivate *) input_window->window;
x_axis = gdkdev->axis_for_use[GDK_AXIS_X];
y_axis = gdkdev->axis_for_use[GDK_AXIS_Y];
g_return_if_fail (window != NULL);
gdk_input_get_root_relative_geometry
- ((((GdkWindowPrivate*) window)->xwindow), &root_x, &root_y);
+ (GDK_DRAWABLE_XID (window), &root_x, &root_y);
input_window->root_x = root_x;
input_window->root_y = root_y;
g_return_if_fail (window != NULL);
gdk_input_get_root_relative_geometry
- ((((GdkWindowPrivate*) window)->xwindow), &root_x, &root_y);
+ (GDK_DRAWABLE_XID (window), &root_x, &root_y);
input_window->root_x = root_x;
input_window->root_y = root_y;
window_private = (GdkWindowPrivate *) window;
- GDK_NOTE (EVENTS, g_print ("gdk_input_win32_other_event: window=%#x (%d,%d)\n", window_private->xwindow, x, y));
+ GDK_NOTE (EVENTS,
+ g_print ("gdk_input_win32_other_event: window=%#x (%d,%d)\n",
+ GDK_DRAWABLE_XID (window), x, y));
#else
/* ??? This code is pretty bogus */
pt.x = x;
pt.y = y;
- ClientToScreen (window_private->xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
gdk_window_unref (window);
window = window_private->parent;
gdk_window_ref (window);
window_private = (GdkWindowPrivate *) window;
- ScreenToClient (window_private->xwindow, &pt);
+ ScreenToClient (GDK_DRAWABLE_XID (window), &pt);
x = pt.x;
y = pt.y;
- GDK_NOTE (EVENTS, g_print ("...propagating to %#x, (%d,%d)\n", window_private->xwindow, x, y));
+ GDK_NOTE (EVENTS, g_print ("...propagating to %#x, (%d,%d)\n",
+ GDK_DRAWABLE_XID (window), x, y));
goto dijkstra;
}
need_ungrab = FALSE;
GDK_NOTE (MISC, g_print ("gdk_input_win32_grab_pointer: %#x %d %#x\n",
- ((GdkWindowPrivate *) window)->xwindow,
+ GDK_DRAWABLE_XID (window),
owner_events,
- (confine_to ?
- ((GdkWindowPrivate *) confine_to)->xwindow :
- 0)));
+ (confine_to ? GDK_DRAWABLE_XID (confine_to) : 0)));
while (tmp_list)
{
guint32 stop,
gint *nevents_return)
{
- GdkWindowPrivate *window_private;
- GdkTimeCoord *coords;
- int i;
-
g_return_val_if_fail (window != NULL, NULL);
- window_private = (GdkWindowPrivate *) window;
- if (window_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return NULL;
*nevents_return = 0;
GdkInputWindow *iw;
g_return_if_fail (window != NULL);
- window_private = (GdkWindowPrivate *) window;
- if (window_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
+ window_private = (GdkWindowPrivate *) window;
if (mode == GDK_EXTENSION_EVENTS_NONE)
mask = 0;
#include "gdk.h"
#include "gdkinput.h"
#include "gdkprivate.h"
+#include "gdkx.h"
#ifdef HAVE_WINTAB
#include <wintab.h>
guint32 deviceid_counter = 0;
#ifdef HAVE_WINTAB
GdkDevicePrivate *gdkdev;
- GdkWindowPrivate *window_private;
+ GdkDrawablePrivate *window_private;
GdkWindowAttr wa;
WORD specversion;
LOGCONTEXT defcontext;
return;
}
gdk_window_ref (wintab_window);
- window_private = (GdkWindowPrivate *) wintab_window;
+ window_private = (GdkDrawablePrivate *) wintab_window;
for (devix = 0; devix < ndevices; devix++)
{
gdouble *xtilt,
gdouble *ytilt)
{
- GdkWindowPrivate *window_private;
+ GdkDrawablePrivate *window_private;
gint x_axis, y_axis, pressure_axis, xtilt_axis, ytilt_axis;
gdouble device_width, device_height;
gdouble x_offset, y_offset, x_scale, y_scale;
- window_private = (GdkWindowPrivate *) input_window->window;
+ window_private = (GdkDrawablePrivate *) input_window->window;
x_axis = gdkdev->axis_for_use[GDK_AXIS_X];
y_axis = gdkdev->axis_for_use[GDK_AXIS_Y];
g_return_if_fail (window != NULL);
gdk_input_get_root_relative_geometry
- ((((GdkWindowPrivate*) window)->xwindow), &root_x, &root_y);
+ (GDK_DRAWABLE_XID (window), &root_x, &root_y);
input_window->root_x = root_x;
input_window->root_y = root_y;
g_return_if_fail (window != NULL);
gdk_input_get_root_relative_geometry
- ((((GdkWindowPrivate*) window)->xwindow), &root_x, &root_y);
+ (GDK_DRAWABLE_XID (window), &root_x, &root_y);
input_window->root_x = root_x;
input_window->root_y = root_y;
window_private = (GdkWindowPrivate *) window;
- GDK_NOTE (EVENTS, g_print ("gdk_input_win32_other_event: window=%#x (%d,%d)\n", window_private->xwindow, x, y));
+ GDK_NOTE (EVENTS,
+ g_print ("gdk_input_win32_other_event: window=%#x (%d,%d)\n",
+ GDK_DRAWABLE_XID (window), x, y));
#else
/* ??? This code is pretty bogus */
pt.x = x;
pt.y = y;
- ClientToScreen (window_private->xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
gdk_window_unref (window);
window = window_private->parent;
gdk_window_ref (window);
window_private = (GdkWindowPrivate *) window;
- ScreenToClient (window_private->xwindow, &pt);
+ ScreenToClient (GDK_DRAWABLE_XID (window), &pt);
x = pt.x;
y = pt.y;
- GDK_NOTE (EVENTS, g_print ("...propagating to %#x, (%d,%d)\n", window_private->xwindow, x, y));
+ GDK_NOTE (EVENTS, g_print ("...propagating to %#x, (%d,%d)\n",
+ GDK_DRAWABLE_XID (window), x, y));
goto dijkstra;
}
need_ungrab = FALSE;
GDK_NOTE (MISC, g_print ("gdk_input_win32_grab_pointer: %#x %d %#x\n",
- ((GdkWindowPrivate *) window)->xwindow,
+ GDK_DRAWABLE_XID (window),
owner_events,
- (confine_to ?
- ((GdkWindowPrivate *) confine_to)->xwindow :
- 0)));
+ (confine_to ? GDK_DRAWABLE_XID (confine_to) : 0)));
while (tmp_list)
{
guint32 stop,
gint *nevents_return)
{
- GdkWindowPrivate *window_private;
- GdkTimeCoord *coords;
- int i;
-
g_return_val_if_fail (window != NULL, NULL);
- window_private = (GdkWindowPrivate *) window;
- if (window_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return NULL;
*nevents_return = 0;
GdkInputWindow *iw;
g_return_if_fail (window != NULL);
- window_private = (GdkWindowPrivate *) window;
- if (window_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
+ window_private = (GdkWindowPrivate *) window;
if (mode == GDK_EXTENSION_EVENTS_NONE)
mask = 0;
{
gint return_val;
- return_val = gdk_root_parent.width;
+ return_val = gdk_root_parent.drawable.width;
return return_val;
}
{
gint return_val;
- return_val = gdk_root_parent.height;
+ return_val = gdk_root_parent.drawable.height;
return return_val;
}
#include "gdkpixmap.h"
#include "gdkprivate.h"
+#include "gdkx.h"
typedef struct
{
gint depth)
{
GdkPixmap *pixmap;
- GdkWindowPrivate *private;
+ GdkDrawablePrivate *private;
GdkWindowPrivate *window_private;
struct {
BITMAPINFOHEADER bmiHeader;
guchar *bits;
gint i;
+ g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
g_return_val_if_fail ((window != NULL) || (depth != -1), NULL);
g_return_val_if_fail ((width != 0) && (height != 0), NULL);
if (!window)
window = (GdkWindow*) &gdk_root_parent;
- window_private = (GdkWindowPrivate*) window;
- if (window_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return NULL;
+ window_private = (GdkWindowPrivate*) window;
if (depth == -1)
- depth = gdk_window_get_visual (window)->depth;
+ depth = gdk_drawable_get_visual (window)->depth;
- GDK_NOTE (MISC, g_print ("gdk_pixmap_new: %dx%dx%d\n", width, height, depth));
+ GDK_NOTE (MISC, g_print ("gdk_pixmap_new: %dx%dx%d\n",
+ width, height, depth));
- private = g_new0 (GdkWindowPrivate, 1);
+ private = g_new0 (GdkDrawablePrivate, 1);
pixmap = (GdkPixmap*) private;
- private->window_type = GDK_WINDOW_PIXMAP;
+ private->window_type = GDK_DRAWABLE_PIXMAP;
- visual = gdk_window_get_visual (window);
-
-#if 0
- if (depth == 1)
- {
- if ((private->xwindow =
- CreateBitmap (width, height, 1, 1, NULL)) == NULL)
- {
- g_warning ("gdk_pixmap_new: CreateBitmap failed");
- g_free (private);
- return NULL;
- }
+ visual = gdk_drawable_get_visual (window);
- private->colormap = NULL;
- }
- else
- {
- if (depth != visual->depth)
- g_warning ("gdk_pixmap_new: depth %d doesn't match display depth %d",
- depth, visual->depth);
-
- if ((hdc = GetDC (window_private->xwindow)) == NULL)
- {
- g_warning ("gdk_pixmap_new: GetDC failed");
- g_free (private);
- return NULL;
- }
-
- if ((private->xwindow =
- CreateCompatibleBitmap (hdc, width, height)) == NULL)
- {
- g_warning ("gdk_pixmap_new: %dx%d CreateCompatibleBitmap failed",
- width, height);
- ReleaseDC (window_private->xwindow, hdc);
- g_free (private);
- return NULL;
- }
-
- ReleaseDC (window_private->xwindow, hdc);
-
- private->colormap = window_private->colormap;
- if (private->colormap == NULL)
- private->colormap = gdk_colormap_get_system ();
- }
-#else
-
- if ((hdc = GetDC (window_private->xwindow)) == NULL)
+ if ((hdc = GetDC (GDK_DRAWABLE_XID (window))) == NULL)
{
g_warning ("gdk_pixmap_new: GetDC failed");
g_free (private);
}
else
{
- private->colormap = window_private->colormap;
+ private->colormap = window_private->drawable.colormap;
if (private->colormap == NULL)
private->colormap = gdk_colormap_get_system ();
iUsage, (PVOID *) &bits, NULL, 0)) == NULL)
{
g_warning ("gdk_pixmap_new: CreateDIBSection failed: %d", GetLastError ());
- ReleaseDC (window_private->xwindow, hdc);
+ ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
g_free (private);
return NULL;
}
- ReleaseDC (window_private->xwindow, hdc);
-
-#endif
+ ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
GDK_NOTE (MISC, g_print ("... = %#x\n", private->xwindow));
- private->parent = NULL;
- private->x = 0;
- private->y = 0;
private->width = width;
private->height = height;
- private->resize_count = 0;
private->ref_count = 1;
private->destroyed = 0;
{
GdkPixmap *pixmap;
GdkImagePrivate *image_private;
- GdkWindowPrivate *private;
+ GdkDrawablePrivate *private;
GdkWindowPrivate *window_private;
g_return_val_if_fail (window != NULL, NULL);
image_private = (GdkImagePrivate *) *image_return;
- private = g_new0 (GdkWindowPrivate, 1);
+ private = g_new0 (GdkDrawablePrivate, 1);
pixmap = (GdkPixmap*) private;
private->xwindow = image_private->ximage;
- private->window_type = GDK_WINDOW_PIXMAP;
- private->colormap = window_private->colormap;
- private->parent = NULL;
- private->x = 0;
- private->y = 0;
+ private->window_type = GDK_DRAWABLE_PIXMAP;
+ private->colormap = window_private->drawable.colormap;
private->width = width;
private->height = height;
- private->resize_count = 0;
private->ref_count = 1;
private->destroyed = 0;
gint height)
{
GdkPixmap *pixmap;
- GdkWindowPrivate *private;
- GdkWindowPrivate *window_private;
+ GdkDrawablePrivate *private;
gint i, j, bpl, aligned_bpl;
guchar *bits;
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail ((width != 0) && (height != 0), NULL);
+ g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
if (!window)
window = (GdkWindow*) &gdk_root_parent;
- window_private = (GdkWindowPrivate*) window;
- if (window_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return NULL;
- private = g_new0 (GdkWindowPrivate, 1);
+ private = g_new0 (GdkDrawablePrivate, 1);
pixmap = (GdkPixmap*) private;
- private->parent = NULL;
- private->window_type = GDK_WINDOW_PIXMAP;
- private->x = 0;
- private->y = 0;
+ private->window_type = GDK_DRAWABLE_PIXMAP;
private->width = width;
private->height = height;
- private->resize_count = 0;
private->ref_count = 1;
private->destroyed = FALSE;
GDK_NOTE (MISC, g_print ("gdk_pixmap_create_from_data: %dx%dx%d = %#x\n",
width, height, depth,
- ((GdkPixmapPrivate *) result)->xwindow));
+ GDK_DRAWABLE_XID (result)));
return result;
}
}
static GdkPixmap *
-_gdk_pixmap_create_from_xpm (GdkWindow *window,
+_gdk_pixmap_create_from_xpm (GdkWindow *window,
GdkColormap *colormap,
- GdkBitmap **mask,
- GdkColor *transparent_color,
- gchar * (*get_buf) (enum buffer_op op,
- gpointer handle),
- gpointer handle)
+ GdkBitmap **mask,
+ GdkColor *transparent_color,
+ gchar * (*get_buf) (enum buffer_op op,
+ gpointer handle),
+ gpointer handle)
{
GdkPixmap *pixmap = NULL;
GdkImage *image = NULL;
gdk_pixmap_foreign_new (guint32 anid)
{
GdkPixmap *pixmap;
+ GdkDrawablePrivate *private;
GdkWindowPrivate *window_private;
- GdkWindowPrivate *private;
HBITMAP xpixmap;
SIZE size;
unsigned int x_ret, y_ret, w_ret, h_ret, bw_ret, depth_ret;
h_ret = size.cy;
/* allocate a new gdk pixmap */
- private = g_new(GdkWindowPrivate, 1);
+ private = g_new (GdkDrawablePrivate, 1);
pixmap = (GdkPixmap *)private;
- private->window_type = GDK_WINDOW_PIXMAP;
+ private->window_type = GDK_DRAWABLE_PIXMAP;
private->xwindow = xpixmap;
private->colormap = NULL;
- private->parent = NULL;
- private->x = 0;
- private->y = 0;
private->width = w_ret;
private->height = h_ret;
- private->resize_count = 0;
private->ref_count = 1;
private->destroyed = 0;
GdkPixmap*
gdk_pixmap_ref (GdkPixmap *pixmap)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *)pixmap;
+ GdkDrawablePrivate *private = (GdkDrawablePrivate *)pixmap;
g_return_val_if_fail (pixmap != NULL, NULL);
+ g_return_val_if_fail (GDK_IS_PIXMAP (private), NULL);
private->ref_count += 1;
return pixmap;
void
gdk_pixmap_unref (GdkPixmap *pixmap)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *)pixmap;
- g_return_if_fail(pixmap != NULL);
+ GdkDrawablePrivate *private = (GdkDrawablePrivate *)pixmap;
+ g_return_if_fail (pixmap != NULL);
+ g_return_if_fail (GDK_IS_PIXMAP (private));
+ g_return_if_fail (private->ref_count > 0);
private->ref_count -= 1;
#include "gdkpixmap.h"
#include "gdkprivate.h"
+#include "gdkx.h"
typedef struct
{
gint depth)
{
GdkPixmap *pixmap;
- GdkWindowPrivate *private;
+ GdkDrawablePrivate *private;
GdkWindowPrivate *window_private;
struct {
BITMAPINFOHEADER bmiHeader;
guchar *bits;
gint i;
+ g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
g_return_val_if_fail ((window != NULL) || (depth != -1), NULL);
g_return_val_if_fail ((width != 0) && (height != 0), NULL);
if (!window)
window = (GdkWindow*) &gdk_root_parent;
- window_private = (GdkWindowPrivate*) window;
- if (window_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return NULL;
+ window_private = (GdkWindowPrivate*) window;
if (depth == -1)
- depth = gdk_window_get_visual (window)->depth;
+ depth = gdk_drawable_get_visual (window)->depth;
- GDK_NOTE (MISC, g_print ("gdk_pixmap_new: %dx%dx%d\n", width, height, depth));
+ GDK_NOTE (MISC, g_print ("gdk_pixmap_new: %dx%dx%d\n",
+ width, height, depth));
- private = g_new0 (GdkWindowPrivate, 1);
+ private = g_new0 (GdkDrawablePrivate, 1);
pixmap = (GdkPixmap*) private;
- private->window_type = GDK_WINDOW_PIXMAP;
+ private->window_type = GDK_DRAWABLE_PIXMAP;
- visual = gdk_window_get_visual (window);
-
-#if 0
- if (depth == 1)
- {
- if ((private->xwindow =
- CreateBitmap (width, height, 1, 1, NULL)) == NULL)
- {
- g_warning ("gdk_pixmap_new: CreateBitmap failed");
- g_free (private);
- return NULL;
- }
+ visual = gdk_drawable_get_visual (window);
- private->colormap = NULL;
- }
- else
- {
- if (depth != visual->depth)
- g_warning ("gdk_pixmap_new: depth %d doesn't match display depth %d",
- depth, visual->depth);
-
- if ((hdc = GetDC (window_private->xwindow)) == NULL)
- {
- g_warning ("gdk_pixmap_new: GetDC failed");
- g_free (private);
- return NULL;
- }
-
- if ((private->xwindow =
- CreateCompatibleBitmap (hdc, width, height)) == NULL)
- {
- g_warning ("gdk_pixmap_new: %dx%d CreateCompatibleBitmap failed",
- width, height);
- ReleaseDC (window_private->xwindow, hdc);
- g_free (private);
- return NULL;
- }
-
- ReleaseDC (window_private->xwindow, hdc);
-
- private->colormap = window_private->colormap;
- if (private->colormap == NULL)
- private->colormap = gdk_colormap_get_system ();
- }
-#else
-
- if ((hdc = GetDC (window_private->xwindow)) == NULL)
+ if ((hdc = GetDC (GDK_DRAWABLE_XID (window))) == NULL)
{
g_warning ("gdk_pixmap_new: GetDC failed");
g_free (private);
}
else
{
- private->colormap = window_private->colormap;
+ private->colormap = window_private->drawable.colormap;
if (private->colormap == NULL)
private->colormap = gdk_colormap_get_system ();
iUsage, (PVOID *) &bits, NULL, 0)) == NULL)
{
g_warning ("gdk_pixmap_new: CreateDIBSection failed: %d", GetLastError ());
- ReleaseDC (window_private->xwindow, hdc);
+ ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
g_free (private);
return NULL;
}
- ReleaseDC (window_private->xwindow, hdc);
-
-#endif
+ ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
GDK_NOTE (MISC, g_print ("... = %#x\n", private->xwindow));
- private->parent = NULL;
- private->x = 0;
- private->y = 0;
private->width = width;
private->height = height;
- private->resize_count = 0;
private->ref_count = 1;
private->destroyed = 0;
{
GdkPixmap *pixmap;
GdkImagePrivate *image_private;
- GdkWindowPrivate *private;
+ GdkDrawablePrivate *private;
GdkWindowPrivate *window_private;
g_return_val_if_fail (window != NULL, NULL);
image_private = (GdkImagePrivate *) *image_return;
- private = g_new0 (GdkWindowPrivate, 1);
+ private = g_new0 (GdkDrawablePrivate, 1);
pixmap = (GdkPixmap*) private;
private->xwindow = image_private->ximage;
- private->window_type = GDK_WINDOW_PIXMAP;
- private->colormap = window_private->colormap;
- private->parent = NULL;
- private->x = 0;
- private->y = 0;
+ private->window_type = GDK_DRAWABLE_PIXMAP;
+ private->colormap = window_private->drawable.colormap;
private->width = width;
private->height = height;
- private->resize_count = 0;
private->ref_count = 1;
private->destroyed = 0;
gint height)
{
GdkPixmap *pixmap;
- GdkWindowPrivate *private;
- GdkWindowPrivate *window_private;
+ GdkDrawablePrivate *private;
gint i, j, bpl, aligned_bpl;
guchar *bits;
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail ((width != 0) && (height != 0), NULL);
+ g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
if (!window)
window = (GdkWindow*) &gdk_root_parent;
- window_private = (GdkWindowPrivate*) window;
- if (window_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return NULL;
- private = g_new0 (GdkWindowPrivate, 1);
+ private = g_new0 (GdkDrawablePrivate, 1);
pixmap = (GdkPixmap*) private;
- private->parent = NULL;
- private->window_type = GDK_WINDOW_PIXMAP;
- private->x = 0;
- private->y = 0;
+ private->window_type = GDK_DRAWABLE_PIXMAP;
private->width = width;
private->height = height;
- private->resize_count = 0;
private->ref_count = 1;
private->destroyed = FALSE;
GDK_NOTE (MISC, g_print ("gdk_pixmap_create_from_data: %dx%dx%d = %#x\n",
width, height, depth,
- ((GdkPixmapPrivate *) result)->xwindow));
+ GDK_DRAWABLE_XID (result)));
return result;
}
}
static GdkPixmap *
-_gdk_pixmap_create_from_xpm (GdkWindow *window,
+_gdk_pixmap_create_from_xpm (GdkWindow *window,
GdkColormap *colormap,
- GdkBitmap **mask,
- GdkColor *transparent_color,
- gchar * (*get_buf) (enum buffer_op op,
- gpointer handle),
- gpointer handle)
+ GdkBitmap **mask,
+ GdkColor *transparent_color,
+ gchar * (*get_buf) (enum buffer_op op,
+ gpointer handle),
+ gpointer handle)
{
GdkPixmap *pixmap = NULL;
GdkImage *image = NULL;
gdk_pixmap_foreign_new (guint32 anid)
{
GdkPixmap *pixmap;
+ GdkDrawablePrivate *private;
GdkWindowPrivate *window_private;
- GdkWindowPrivate *private;
HBITMAP xpixmap;
SIZE size;
unsigned int x_ret, y_ret, w_ret, h_ret, bw_ret, depth_ret;
h_ret = size.cy;
/* allocate a new gdk pixmap */
- private = g_new(GdkWindowPrivate, 1);
+ private = g_new (GdkDrawablePrivate, 1);
pixmap = (GdkPixmap *)private;
- private->window_type = GDK_WINDOW_PIXMAP;
+ private->window_type = GDK_DRAWABLE_PIXMAP;
private->xwindow = xpixmap;
private->colormap = NULL;
- private->parent = NULL;
- private->x = 0;
- private->y = 0;
private->width = w_ret;
private->height = h_ret;
- private->resize_count = 0;
private->ref_count = 1;
private->destroyed = 0;
GdkPixmap*
gdk_pixmap_ref (GdkPixmap *pixmap)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *)pixmap;
+ GdkDrawablePrivate *private = (GdkDrawablePrivate *)pixmap;
g_return_val_if_fail (pixmap != NULL, NULL);
+ g_return_val_if_fail (GDK_IS_PIXMAP (private), NULL);
private->ref_count += 1;
return pixmap;
void
gdk_pixmap_unref (GdkPixmap *pixmap)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *)pixmap;
- g_return_if_fail(pixmap != NULL);
+ GdkDrawablePrivate *private = (GdkDrawablePrivate *)pixmap;
+ g_return_if_fail (pixmap != NULL);
+ g_return_if_fail (GDK_IS_PIXMAP (private));
+ g_return_if_fail (private->ref_count > 0);
private->ref_count -= 1;
#include <time.h>
+#include <gdk/gdktypes.h>
+
#include <gdk/gdkcursor.h>
#include <gdk/gdkevents.h>
#include <gdk/gdkfont.h>
#include <gdk/gdkvisual.h>
#include <gdk/gdkwindow.h>
-#include <gdk/gdktypes.h>
+#define GDK_DRAWABLE_TYPE(d) (((GdkDrawablePrivate *)d)->window_type)
+#define GDK_IS_WINDOW(d) (GDK_DRAWABLE_TYPE(d) <= GDK_WINDOW_TEMP || \
+ GDK_DRAWABLE_TYPE(d) == GDK_WINDOW_FOREIGN)
+#define GDK_IS_PIXMAP(d) (GDK_DRAWABLE_TYPE(d) == GDK_DRAWABLE_PIXMAP)
+#define GDK_DRAWABLE_DESTROYED(d) (((GdkDrawablePrivate *)d)->destroyed)
#define gdk_window_lookup(xid) ((GdkWindow*) gdk_xid_table_lookup (xid))
#define gdk_pixmap_lookup(xid) ((GdkPixmap*) gdk_xid_table_lookup (xid))
unsigned long base_pixel;
} XStandardColormap;
+typedef struct _GdkDrawablePrivate GdkDrawablePrivate;
+/* typedef struct _GdkDrawablePrivate GdkPixmapPrivate; */
typedef struct _GdkWindowPrivate GdkWindowPrivate;
-typedef struct _GdkWindowPrivate GdkPixmapPrivate;
typedef struct _GdkImagePrivate GdkImagePrivate;
typedef struct _GdkGCPrivate GdkGCPrivate;
typedef struct _GdkColormapPrivate GdkColormapPrivate;
typedef struct _GdkClientFilter GdkClientFilter;
typedef struct _GdkRegionPrivate GdkRegionPrivate;
+struct _GdkDrawablePrivate
+{
+ GdkDrawable drawable;
+
+ guint8 window_type;
+ guint ref_count;
+
+ guint16 width;
+ guint16 height;
+
+ HANDLE xwindow;
+ GdkColormap *colormap;
+
+ guint destroyed : 2;
+};
struct _GdkWindowPrivate
{
- GdkWindow window;
+ GdkDrawablePrivate drawable;
+
GdkWindow *parent;
- HANDLE xwindow;
gint16 x;
gint16 y;
- guint16 width;
- guint16 height;
guint8 resize_count;
- guint8 window_type;
- guint ref_count;
- guint destroyed : 2;
guint mapped : 1;
guint guffaw_gravity : 1;
gboolean extension_events_selected;
GList *filters;
- GdkColormap *colormap;
GList *children;
};
gpointer data;
};
-#ifdef USE_XIM
-
-typedef struct _GdkICPrivate GdkICPrivate;
-
-struct _GdkICPrivate
-{
- XIC xic;
- GdkICAttr *attr;
- GdkICAttributesType mask;
-};
-
-#endif /* USE_XIM */
-
struct _GdkRegionPrivate
{
GdkRegion region;
/* Internal functions */
-HDC gdk_gc_predraw (GdkWindowPrivate *window_private,
- GdkGCPrivate *gc_private);
-void gdk_gc_postdraw (GdkWindowPrivate *window_private,
- GdkGCPrivate *gc_private);
+HDC gdk_gc_predraw (GdkDrawablePrivate *drawable_private,
+ GdkGCPrivate *gc_private);
+void gdk_gc_postdraw (GdkDrawablePrivate *drawable_private,
+ GdkGCPrivate *gc_private);
HRGN BitmapToRegion (HBITMAP hBmp);
void gdk_sel_prop_store (GdkWindow *owner,
extern gint gdk_debug_level;
extern gint gdk_show_events;
extern gint gdk_stack_trace;
-extern gchar *gdk_display_name;
extern HWND gdk_root_window;
extern HWND gdk_leader_window;
GDKVAR GdkWindowPrivate gdk_root_parent;
extern GList *gdk_default_filters;
extern gint gdk_event_func_from_window_proc;
-#ifdef USE_XIM
-/* XIM support */
-gint gdk_im_open (void);
-void gdk_im_close (void);
-void gdk_ic_cleanup (void);
-
-extern GdkICPrivate *gdk_xim_ic; /* currently using IC */
-extern GdkWindow *gdk_xim_window; /* currently using Window */
-#endif /* USE_XIM */
-
extern HDC gdk_DC;
extern HINSTANCE gdk_DLLInstance;
extern HINSTANCE gdk_ProgInstance;
#include <time.h>
+#include <gdk/gdktypes.h>
+
#include <gdk/gdkcursor.h>
#include <gdk/gdkevents.h>
#include <gdk/gdkfont.h>
#include <gdk/gdkvisual.h>
#include <gdk/gdkwindow.h>
-#include <gdk/gdktypes.h>
+#define GDK_DRAWABLE_TYPE(d) (((GdkDrawablePrivate *)d)->window_type)
+#define GDK_IS_WINDOW(d) (GDK_DRAWABLE_TYPE(d) <= GDK_WINDOW_TEMP || \
+ GDK_DRAWABLE_TYPE(d) == GDK_WINDOW_FOREIGN)
+#define GDK_IS_PIXMAP(d) (GDK_DRAWABLE_TYPE(d) == GDK_DRAWABLE_PIXMAP)
+#define GDK_DRAWABLE_DESTROYED(d) (((GdkDrawablePrivate *)d)->destroyed)
#define gdk_window_lookup(xid) ((GdkWindow*) gdk_xid_table_lookup (xid))
#define gdk_pixmap_lookup(xid) ((GdkPixmap*) gdk_xid_table_lookup (xid))
unsigned long base_pixel;
} XStandardColormap;
+typedef struct _GdkDrawablePrivate GdkDrawablePrivate;
+/* typedef struct _GdkDrawablePrivate GdkPixmapPrivate; */
typedef struct _GdkWindowPrivate GdkWindowPrivate;
-typedef struct _GdkWindowPrivate GdkPixmapPrivate;
typedef struct _GdkImagePrivate GdkImagePrivate;
typedef struct _GdkGCPrivate GdkGCPrivate;
typedef struct _GdkColormapPrivate GdkColormapPrivate;
typedef struct _GdkClientFilter GdkClientFilter;
typedef struct _GdkRegionPrivate GdkRegionPrivate;
+struct _GdkDrawablePrivate
+{
+ GdkDrawable drawable;
+
+ guint8 window_type;
+ guint ref_count;
+
+ guint16 width;
+ guint16 height;
+
+ HANDLE xwindow;
+ GdkColormap *colormap;
+
+ guint destroyed : 2;
+};
struct _GdkWindowPrivate
{
- GdkWindow window;
+ GdkDrawablePrivate drawable;
+
GdkWindow *parent;
- HANDLE xwindow;
gint16 x;
gint16 y;
- guint16 width;
- guint16 height;
guint8 resize_count;
- guint8 window_type;
- guint ref_count;
- guint destroyed : 2;
guint mapped : 1;
guint guffaw_gravity : 1;
gboolean extension_events_selected;
GList *filters;
- GdkColormap *colormap;
GList *children;
};
gpointer data;
};
-#ifdef USE_XIM
-
-typedef struct _GdkICPrivate GdkICPrivate;
-
-struct _GdkICPrivate
-{
- XIC xic;
- GdkICAttr *attr;
- GdkICAttributesType mask;
-};
-
-#endif /* USE_XIM */
-
struct _GdkRegionPrivate
{
GdkRegion region;
/* Internal functions */
-HDC gdk_gc_predraw (GdkWindowPrivate *window_private,
- GdkGCPrivate *gc_private);
-void gdk_gc_postdraw (GdkWindowPrivate *window_private,
- GdkGCPrivate *gc_private);
+HDC gdk_gc_predraw (GdkDrawablePrivate *drawable_private,
+ GdkGCPrivate *gc_private);
+void gdk_gc_postdraw (GdkDrawablePrivate *drawable_private,
+ GdkGCPrivate *gc_private);
HRGN BitmapToRegion (HBITMAP hBmp);
void gdk_sel_prop_store (GdkWindow *owner,
extern gint gdk_debug_level;
extern gint gdk_show_events;
extern gint gdk_stack_trace;
-extern gchar *gdk_display_name;
extern HWND gdk_root_window;
extern HWND gdk_leader_window;
GDKVAR GdkWindowPrivate gdk_root_parent;
extern GList *gdk_default_filters;
extern gint gdk_event_func_from_window_proc;
-#ifdef USE_XIM
-/* XIM support */
-gint gdk_im_open (void);
-void gdk_im_close (void);
-void gdk_ic_cleanup (void);
-
-extern GdkICPrivate *gdk_xim_ic; /* currently using IC */
-extern GdkWindow *gdk_xim_window; /* currently using Window */
-#endif /* USE_XIM */
-
extern HDC gdk_DC;
extern HINSTANCE gdk_DLLInstance;
extern HINSTANCE gdk_ProgInstance;
#include "gdkproperty.h"
#include "gdkselection.h"
#include "gdkprivate.h"
+#include "gdkx.h"
GdkAtom
gdk_atom_intern (const gchar *atom_name,
guchar *data,
gint nelements)
{
- GdkWindowPrivate *private;
HGLOBAL hdata;
gint i, length;
gchar *prop_name, *type_name;
guchar *ptr;
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
GDK_NOTE (SELECTION,
(prop_name = gdk_atom_name (property),
type_name = gdk_atom_name (type),
g_print ("gdk_property_change: %#x %#x (%s) %#x (%s) %s %d*%d bytes %.10s\n",
- private->xwindow, property, prop_name,
+ GDK_DRAWABLE_XID (window), property, prop_name,
type, type_name,
(mode == GDK_PROP_MODE_REPLACE ? "REPLACE" :
(mode == GDK_PROP_MODE_PREPEND ? "PREPEND" :
length++;
#if 1
GDK_NOTE (SELECTION, g_print ("...OpenClipboard(%#x)\n",
- private->xwindow));
- if (!OpenClipboard (private->xwindow))
+ GDK_DRAWABLE_XID (window)));
+ if (!OpenClipboard (GDK_DRAWABLE_XID (window)))
{
g_warning ("gdk_property_change: OpenClipboard failed");
return;
gdk_property_delete (GdkWindow *window,
GdkAtom property)
{
- GdkWindowPrivate *private;
gchar *prop_name, *type_name;
- extern void gdk_selection_property_delete (GdkWindowPrivate *);
+ extern void gdk_selection_property_delete (GdkWindow *);
- private = (GdkWindowPrivate*) window;
+ if (GDK_DRAWABLE_DESTROYED (window))
+ return;
GDK_NOTE (SELECTION,
(prop_name = gdk_atom_name (property),
g_print ("gdk_property_delete: %#x %#x (%s)\n",
- (window ? private->xwindow : 0), property, prop_name),
+ (window ? GDK_DRAWABLE_XID (window) : 0),
+ property, prop_name),
g_free (prop_name)));
if (property == gdk_selection_property)
- gdk_selection_property_delete (private);
+ gdk_selection_property_delete (window);
else
g_warning ("gdk_property_delete: General case not implemented");
}
#include "gdkproperty.h"
#include "gdkselection.h"
#include "gdkprivate.h"
+#include "gdkx.h"
GdkAtom
gdk_atom_intern (const gchar *atom_name,
guchar *data,
gint nelements)
{
- GdkWindowPrivate *private;
HGLOBAL hdata;
gint i, length;
gchar *prop_name, *type_name;
guchar *ptr;
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
GDK_NOTE (SELECTION,
(prop_name = gdk_atom_name (property),
type_name = gdk_atom_name (type),
g_print ("gdk_property_change: %#x %#x (%s) %#x (%s) %s %d*%d bytes %.10s\n",
- private->xwindow, property, prop_name,
+ GDK_DRAWABLE_XID (window), property, prop_name,
type, type_name,
(mode == GDK_PROP_MODE_REPLACE ? "REPLACE" :
(mode == GDK_PROP_MODE_PREPEND ? "PREPEND" :
length++;
#if 1
GDK_NOTE (SELECTION, g_print ("...OpenClipboard(%#x)\n",
- private->xwindow));
- if (!OpenClipboard (private->xwindow))
+ GDK_DRAWABLE_XID (window)));
+ if (!OpenClipboard (GDK_DRAWABLE_XID (window)))
{
g_warning ("gdk_property_change: OpenClipboard failed");
return;
gdk_property_delete (GdkWindow *window,
GdkAtom property)
{
- GdkWindowPrivate *private;
gchar *prop_name, *type_name;
- extern void gdk_selection_property_delete (GdkWindowPrivate *);
+ extern void gdk_selection_property_delete (GdkWindow *);
- private = (GdkWindowPrivate*) window;
+ if (GDK_DRAWABLE_DESTROYED (window))
+ return;
GDK_NOTE (SELECTION,
(prop_name = gdk_atom_name (property),
g_print ("gdk_property_delete: %#x %#x (%s)\n",
- (window ? private->xwindow : 0), property, prop_name),
+ (window ? GDK_DRAWABLE_XID (window) : 0),
+ property, prop_name),
g_free (prop_name)));
if (property == gdk_selection_property)
- gdk_selection_property_delete (private);
+ gdk_selection_property_delete (window);
else
g_warning ("gdk_property_delete: General case not implemented");
}
guchar *data,
gint length)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *) owner;
GdkSelProp *prop;
- prop = g_hash_table_lookup (sel_prop_table, &private->xwindow);
+ prop = g_hash_table_lookup (sel_prop_table, &GDK_DRAWABLE_XID (owner));
if (prop != NULL)
{
g_free (prop->data);
- g_hash_table_remove (sel_prop_table, &private->xwindow);
+ g_hash_table_remove (sel_prop_table, &GDK_DRAWABLE_XID (owner));
}
prop = g_new (GdkSelProp, 1);
prop->data = data;
prop->length = length;
prop->format = format;
prop->type = type;
- g_hash_table_insert (sel_prop_table, &private->xwindow, prop);
+ g_hash_table_insert (sel_prop_table, &GDK_DRAWABLE_XID (owner), prop);
}
-
gint
gdk_selection_owner_set (GdkWindow *owner,
guint32 time,
gint send_event)
{
- GdkWindowPrivate *private;
gchar *sel_name;
HWND xwindow;
- private = (GdkWindowPrivate *) owner;
-
GDK_NOTE (SELECTION,
(sel_name = gdk_atom_name (selection),
g_print ("gdk_selection_owner_set: %#x %#x (%s)\n",
- (private ? private->xwindow : 0),
+ (owner ? GDK_DRAWABLE_XID (owner) : 0),
selection, sel_name),
g_free (sel_name)));
return FALSE;
if (owner != NULL)
- xwindow = private->xwindow;
+ xwindow = GDK_DRAWABLE_XID (owner);
else
xwindow = NULL;
/* Send ourselves an ersatz selection request message so that
* gdk_property_change will be called to store the clipboard data.
*/
- SendMessage (private->xwindow, gdk_selection_request_msg,
+ SendMessage (xwindow, gdk_selection_request_msg,
selection, 0);
}
gdk_selection_owner_get (GdkAtom selection)
{
GdkWindow *window;
- GdkWindowPrivate *private;
gchar *sel_name;
#if 1
else
window = gdk_window_lookup (GetClipboardOwner ());
- private = (GdkWindowPrivate *) window;
#endif
GDK_NOTE (SELECTION,
(sel_name = gdk_atom_name (selection),
g_print ("gdk_selection_owner_get: %#x (%s) = %#x\n",
selection, sel_name,
- (private ? private->xwindow : 0)),
+ (window ? GDK_DRAWABLE_XID (window) : 0)),
g_free (sel_name)));
return window;
GdkAtom target,
guint32 time)
{
- GdkWindowPrivate *private;
HGLOBAL hdata;
GdkSelProp *prop;
guchar *ptr, *data, *datap, *p;
gchar *sel_name, *tgt_name;
g_return_if_fail (requestor != NULL);
-
- private = (GdkWindowPrivate*) requestor;
+ if (GDK_DRAWABLE_DESTROYED (requestor))
+ return;
GDK_NOTE (SELECTION,
(sel_name = gdk_atom_name (selection),
tgt_name = gdk_atom_name (target),
g_print ("gdk_selection_convert: %#x %#x (%s) %#x (%s)\n",
- private->xwindow, selection, sel_name, target, tgt_name),
+ GDK_DRAWABLE_XID (requestor), selection, sel_name, target, tgt_name),
g_free (sel_name),
g_free (tgt_name)));
* and store it for later.
*/
GDK_NOTE (SELECTION, g_print ("...OpenClipboard(%#x)\n",
- private->xwindow));
- if (!OpenClipboard (private->xwindow))
+ GDK_DRAWABLE_XID (requestor)));
+ if (!OpenClipboard (GDK_DRAWABLE_XID (requestor)))
{
g_warning ("gdk_selection_convert: OpenClipboard failed");
return;
/* Send ourselves an ersatz selection notify message so that we actually
* fetch the data.
*/
- SendMessage (private->xwindow, gdk_selection_notify_msg, selection, target);
+ SendMessage (GDK_DRAWABLE_XID (requestor), gdk_selection_notify_msg, selection, target);
}
else if (selection == gdk_win32_dropfiles_atom)
{
*/
GdkSelProp *prop;
- prop = g_hash_table_lookup (sel_prop_table, &gdk_root_parent.xwindow);
+ prop = g_hash_table_lookup (sel_prop_table, &gdk_root_parent.drawable.xwindow);
if (prop != NULL)
{
- g_hash_table_remove (sel_prop_table, &gdk_root_parent.xwindow);
+ g_hash_table_remove (sel_prop_table, &gdk_root_parent.drawable.xwindow);
gdk_sel_prop_store (requestor, prop->type, prop->format,
prop->data, prop->length);
g_free (prop);
- SendMessage (private->xwindow, gdk_selection_notify_msg, selection, target);
+ SendMessage (GDK_DRAWABLE_XID (requestor), gdk_selection_notify_msg, selection, target);
}
}
else
GdkAtom *ret_type,
gint *ret_format)
{
- GdkWindowPrivate *private;
GdkSelProp *prop;
g_return_val_if_fail (requestor != NULL, 0);
+ g_return_val_if_fail (GDK_IS_WINDOW (requestor), 0);
- private = (GdkWindowPrivate*) requestor;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (requestor))
return 0;
GDK_NOTE (SELECTION, g_print ("gdk_selection_property_get: %#x\n",
- private->xwindow));
+ GDK_DRAWABLE_XID (requestor)));
- prop = g_hash_table_lookup (sel_prop_table, &private->xwindow);
+ prop = g_hash_table_lookup (sel_prop_table, &GDK_DRAWABLE_XID (requestor));
if (prop == NULL)
{
}
void
-gdk_selection_property_delete (GdkWindowPrivate *private)
+gdk_selection_property_delete (GdkWindow *window)
{
GdkSelProp *prop;
- prop = g_hash_table_lookup (sel_prop_table, &private->xwindow);
+ prop = g_hash_table_lookup (sel_prop_table, &GDK_DRAWABLE_XID (window));
if (prop != NULL)
{
g_free (prop->data);
- g_hash_table_remove (sel_prop_table, &private->xwindow);
+ g_hash_table_remove (sel_prop_table, &GDK_DRAWABLE_XID (window));
}
else
g_warning ("huh?");
guchar *data,
gint length)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *) owner;
GdkSelProp *prop;
- prop = g_hash_table_lookup (sel_prop_table, &private->xwindow);
+ prop = g_hash_table_lookup (sel_prop_table, &GDK_DRAWABLE_XID (owner));
if (prop != NULL)
{
g_free (prop->data);
- g_hash_table_remove (sel_prop_table, &private->xwindow);
+ g_hash_table_remove (sel_prop_table, &GDK_DRAWABLE_XID (owner));
}
prop = g_new (GdkSelProp, 1);
prop->data = data;
prop->length = length;
prop->format = format;
prop->type = type;
- g_hash_table_insert (sel_prop_table, &private->xwindow, prop);
+ g_hash_table_insert (sel_prop_table, &GDK_DRAWABLE_XID (owner), prop);
}
-
gint
gdk_selection_owner_set (GdkWindow *owner,
guint32 time,
gint send_event)
{
- GdkWindowPrivate *private;
gchar *sel_name;
HWND xwindow;
- private = (GdkWindowPrivate *) owner;
-
GDK_NOTE (SELECTION,
(sel_name = gdk_atom_name (selection),
g_print ("gdk_selection_owner_set: %#x %#x (%s)\n",
- (private ? private->xwindow : 0),
+ (owner ? GDK_DRAWABLE_XID (owner) : 0),
selection, sel_name),
g_free (sel_name)));
return FALSE;
if (owner != NULL)
- xwindow = private->xwindow;
+ xwindow = GDK_DRAWABLE_XID (owner);
else
xwindow = NULL;
/* Send ourselves an ersatz selection request message so that
* gdk_property_change will be called to store the clipboard data.
*/
- SendMessage (private->xwindow, gdk_selection_request_msg,
+ SendMessage (xwindow, gdk_selection_request_msg,
selection, 0);
}
gdk_selection_owner_get (GdkAtom selection)
{
GdkWindow *window;
- GdkWindowPrivate *private;
gchar *sel_name;
#if 1
else
window = gdk_window_lookup (GetClipboardOwner ());
- private = (GdkWindowPrivate *) window;
#endif
GDK_NOTE (SELECTION,
(sel_name = gdk_atom_name (selection),
g_print ("gdk_selection_owner_get: %#x (%s) = %#x\n",
selection, sel_name,
- (private ? private->xwindow : 0)),
+ (window ? GDK_DRAWABLE_XID (window) : 0)),
g_free (sel_name)));
return window;
GdkAtom target,
guint32 time)
{
- GdkWindowPrivate *private;
HGLOBAL hdata;
GdkSelProp *prop;
guchar *ptr, *data, *datap, *p;
gchar *sel_name, *tgt_name;
g_return_if_fail (requestor != NULL);
-
- private = (GdkWindowPrivate*) requestor;
+ if (GDK_DRAWABLE_DESTROYED (requestor))
+ return;
GDK_NOTE (SELECTION,
(sel_name = gdk_atom_name (selection),
tgt_name = gdk_atom_name (target),
g_print ("gdk_selection_convert: %#x %#x (%s) %#x (%s)\n",
- private->xwindow, selection, sel_name, target, tgt_name),
+ GDK_DRAWABLE_XID (requestor), selection, sel_name, target, tgt_name),
g_free (sel_name),
g_free (tgt_name)));
* and store it for later.
*/
GDK_NOTE (SELECTION, g_print ("...OpenClipboard(%#x)\n",
- private->xwindow));
- if (!OpenClipboard (private->xwindow))
+ GDK_DRAWABLE_XID (requestor)));
+ if (!OpenClipboard (GDK_DRAWABLE_XID (requestor)))
{
g_warning ("gdk_selection_convert: OpenClipboard failed");
return;
/* Send ourselves an ersatz selection notify message so that we actually
* fetch the data.
*/
- SendMessage (private->xwindow, gdk_selection_notify_msg, selection, target);
+ SendMessage (GDK_DRAWABLE_XID (requestor), gdk_selection_notify_msg, selection, target);
}
else if (selection == gdk_win32_dropfiles_atom)
{
*/
GdkSelProp *prop;
- prop = g_hash_table_lookup (sel_prop_table, &gdk_root_parent.xwindow);
+ prop = g_hash_table_lookup (sel_prop_table, &gdk_root_parent.drawable.xwindow);
if (prop != NULL)
{
- g_hash_table_remove (sel_prop_table, &gdk_root_parent.xwindow);
+ g_hash_table_remove (sel_prop_table, &gdk_root_parent.drawable.xwindow);
gdk_sel_prop_store (requestor, prop->type, prop->format,
prop->data, prop->length);
g_free (prop);
- SendMessage (private->xwindow, gdk_selection_notify_msg, selection, target);
+ SendMessage (GDK_DRAWABLE_XID (requestor), gdk_selection_notify_msg, selection, target);
}
}
else
GdkAtom *ret_type,
gint *ret_format)
{
- GdkWindowPrivate *private;
GdkSelProp *prop;
g_return_val_if_fail (requestor != NULL, 0);
+ g_return_val_if_fail (GDK_IS_WINDOW (requestor), 0);
- private = (GdkWindowPrivate*) requestor;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (requestor))
return 0;
GDK_NOTE (SELECTION, g_print ("gdk_selection_property_get: %#x\n",
- private->xwindow));
+ GDK_DRAWABLE_XID (requestor)));
- prop = g_hash_table_lookup (sel_prop_table, &private->xwindow);
+ prop = g_hash_table_lookup (sel_prop_table, &GDK_DRAWABLE_XID (requestor));
if (prop == NULL)
{
}
void
-gdk_selection_property_delete (GdkWindowPrivate *private)
+gdk_selection_property_delete (GdkWindow *window)
{
GdkSelProp *prop;
- prop = g_hash_table_lookup (sel_prop_table, &private->xwindow);
+ prop = g_hash_table_lookup (sel_prop_table, &GDK_DRAWABLE_XID (window));
if (prop != NULL)
{
g_free (prop->data);
- g_hash_table_remove (sel_prop_table, &private->xwindow);
+ g_hash_table_remove (sel_prop_table, &GDK_DRAWABLE_XID (window));
}
else
g_warning ("huh?");
#define GDK_ROOT_WINDOW() ((guint32) HWND_DESKTOP)
#define GDK_ROOT_PARENT() ((GdkWindow *)&gdk_root_parent)
#define GDK_DISPLAY() NULL
-#define GDK_WINDOW_XDISPLAY(win) NULL
-#define GDK_WINDOW_XWINDOW(win) (((GdkWindowPrivate*) win)->xwindow)
+#define GDK_DRAWABLE_XDISPLAY(win) NULL
+#define GDK_DRAWABLE_XID(win) (((GdkDrawablePrivate*) win)->xwindow)
+#define GDK_WINDOW_XDISPLAY GDK_DRAWABLE_XDISPLAY
+#define GDK_WINDOW_XWINDOW GDK_DRAWABLE_XID
#define GDK_IMAGE_XDISPLAY(image) NULL
#define GDK_IMAGE_XIMAGE(image) (((GdkImagePrivate*) image)->ximage)
#define GDK_GC_XDISPLAY(gc) NULL
#include "gdkwindow.h"
#include "gdkprivate.h"
#include "gdkinputprivate.h"
+#include "gdkx.h"
/* The Win API function AdjustWindowRect may return negative values
* resulting in obscured title bars. This helper function is coreccting it.
}
#endif
- gdk_root_parent.xwindow = gdk_root_window;
- gdk_root_parent.window_type = GDK_WINDOW_ROOT;
- gdk_root_parent.window.user_data = NULL;
- gdk_root_parent.width = width;
- gdk_root_parent.height = height;
+ gdk_root_parent.drawable.xwindow = gdk_root_window;
+ gdk_root_parent.drawable.window_type = GDK_WINDOW_ROOT;
+ gdk_root_parent.drawable.drawable.user_data = NULL;
+ gdk_root_parent.drawable.width = width;
+ gdk_root_parent.drawable.height = height;
+ gdk_root_parent.drawable.ref_count = 1;
+ gdk_root_parent.drawable.colormap = NULL;
gdk_root_parent.children = NULL;
- gdk_root_parent.colormap = NULL;
- gdk_root_parent.ref_count = 1;
gdk_xid_table_insert (&gdk_root_window, &gdk_root_parent);
}
case GDK_WINDOW_ROOT:
g_error ("cannot make windows of type GDK_WINDOW_ROOT");
break;
- case GDK_WINDOW_PIXMAP:
- g_error ("cannot make windows of type GDK_WINDOW_PIXMAP (use gdk_pixmap_new)");
+ case GDK_DRAWABLE_PIXMAP:
+ g_error ("cannot make windows of type GDK_DRAWABLE_PIXMAP (use gdk_pixmap_new)");
break;
}
parent = (GdkWindow*) &gdk_root_parent;
parent_private = (GdkWindowPrivate*) parent;
- if (parent_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (parent))
return NULL;
- xparent = parent_private->xwindow;
+ xparent = parent_private->drawable.xwindow;
private = g_new (GdkWindowPrivate, 1);
window = (GdkWindow*) private;
private->parent = parent;
- private->destroyed = FALSE;
+ private->drawable.destroyed = FALSE;
private->mapped = FALSE;
private->guffaw_gravity = FALSE;
private->resize_count = 0;
- private->ref_count = 1;
+ private->drawable.ref_count = 1;
private->x = (attributes_mask & GDK_WA_X) ? attributes->x : 0;
private->y = (attributes_mask & GDK_WA_Y) ? attributes->y : 0;
- private->width = (attributes->width > 1) ? (attributes->width) : (1);
- private->height = (attributes->height > 1) ? (attributes->height) : (1);
- private->window_type = attributes->window_type;
+ private->drawable.width = (attributes->width > 1) ? (attributes->width) : (1);
+ private->drawable.height = (attributes->height > 1) ? (attributes->height) : (1);
+ private->drawable.window_type = attributes->window_type;
private->extension_events = 0;
private->extension_events_selected = FALSE;
{
dwExStyle = 0;
if (attributes_mask & GDK_WA_COLORMAP)
- private->colormap = attributes->colormap;
+ private->drawable.colormap = attributes->colormap;
else
- private->colormap = gdk_colormap_get_system ();
+ private->drawable.colormap = gdk_colormap_get_system ();
}
else
{
dwExStyle = WS_EX_TRANSPARENT;
- private->colormap = NULL;
+ private->drawable.colormap = NULL;
private->bg_type = GDK_WIN32_BG_TRANSPARENT;
private->bg_pixmap = NULL;
}
if (parent_private)
parent_private->children = g_list_prepend (parent_private->children, window);
- switch (private->window_type)
+ switch (private->drawable.window_type)
{
case GDK_WINDOW_TOPLEVEL:
dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN;
case GDK_WINDOW_ROOT:
g_error ("cannot make windows of type GDK_WINDOW_ROOT");
break;
- case GDK_WINDOW_PIXMAP:
- g_error ("cannot make windows of type GDK_WINDOW_PIXMAP (use gdk_pixmap_new)");
+ case GDK_DRAWABLE_PIXMAP:
+ g_error ("cannot make windows of type GDK_DRAWABLE_PIXMAP (use gdk_pixmap_new)");
break;
}
- klass = RegisterGdkClass (private->window_type);
+ klass = RegisterGdkClass (private->drawable.window_type);
if (!klass)
g_error ("RegisterClassEx failed");
- if (private->window_type != GDK_WINDOW_CHILD)
+ if (private->drawable.window_type != GDK_WINDOW_CHILD)
{
if (x == CW_USEDEFAULT)
{
rect.top = y;
}
- rect.right = rect.left + private->width;
- rect.bottom = rect.top + private->height;
+ rect.right = rect.left + private->drawable.width;
+ rect.bottom = rect.top + private->drawable.height;
if (!SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
g_warning ("gdk_window_new: AdjustWindowRectEx failed");
}
else
{
- width = private->width;
- height = private->height;
+ width = private->drawable.width;
+ height = private->drawable.height;
}
- private->xwindow =
+ private->drawable.xwindow =
CreateWindowEx (dwExStyle,
MAKEINTRESOURCE(klass),
title,
NULL);
GDK_NOTE (MISC,
g_print ("gdk_window_create: %s %s %#x %#x %dx%d@+%d+%d %#x = %#x\n",
- (private->window_type == GDK_WINDOW_TOPLEVEL ? "TOPLEVEL" :
- (private->window_type == GDK_WINDOW_CHILD ? "CHILD" :
- (private->window_type == GDK_WINDOW_DIALOG ? "DIALOG" :
- (private->window_type == GDK_WINDOW_TEMP ? "TEMP" :
+ (private->drawable.window_type == GDK_WINDOW_TOPLEVEL ? "TOPLEVEL" :
+ (private->drawable.window_type == GDK_WINDOW_CHILD ? "CHILD" :
+ (private->drawable.window_type == GDK_WINDOW_DIALOG ? "DIALOG" :
+ (private->drawable.window_type == GDK_WINDOW_TEMP ? "TEMP" :
"???")))),
title,
dwStyle,
private->event_mask,
width, height, (x == CW_USEDEFAULT ? -9999 : x), y,
xparent,
- private->xwindow));
+ private->drawable.xwindow));
gdk_window_ref (window);
- gdk_xid_table_insert (&private->xwindow, window);
+ gdk_xid_table_insert (&private->drawable.xwindow, window);
- if (private->colormap)
- gdk_colormap_ref (private->colormap);
+ if (private->drawable.colormap)
+ gdk_colormap_ref (private->drawable.colormap);
gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
(attributes->cursor) :
if (parent_private)
parent_private->children = g_list_prepend (parent_private->children, window);
- private->xwindow = (HWND) anid;
+ private->drawable.xwindow = (HWND) anid;
GetClientRect ((HWND) anid, &rect);
point.x = rect.left;
point.y = rect.right;
ScreenToClient (parent, &point);
private->x = point.x;
private->y = point.y;
- private->width = rect.right - rect.left;
- private->height = rect.bottom - rect.top;
+ private->drawable.width = rect.right - rect.left;
+ private->drawable.height = rect.bottom - rect.top;
private->resize_count = 0;
- private->ref_count = 1;
- private->window_type = GDK_WINDOW_FOREIGN;
- private->destroyed = FALSE;
- private->mapped = IsWindowVisible (private->xwindow);
+ private->drawable.ref_count = 1;
+ private->drawable.window_type = GDK_WINDOW_FOREIGN;
+ private->drawable.destroyed = FALSE;
+ private->mapped = IsWindowVisible (private->drawable.xwindow);
private->guffaw_gravity = FALSE;
private->extension_events = 0;
private->extension_events_selected = FALSE;
- private->colormap = NULL;
+ private->drawable.colormap = NULL;
private->filters = NULL;
private->children = NULL;
window->user_data = NULL;
gdk_window_ref (window);
- gdk_xid_table_insert (&private->xwindow, window);
+ gdk_xid_table_insert (&private->drawable.xwindow, window);
return window;
}
private = (GdkWindowPrivate*) window;
GDK_NOTE (MISC, g_print ("gdk_window_internal_destroy %#x\n",
- private->xwindow));
+ private->drawable.xwindow));
- switch (private->window_type)
+ switch (private->drawable.window_type)
{
case GDK_WINDOW_TOPLEVEL:
case GDK_WINDOW_CHILD:
case GDK_WINDOW_DIALOG:
case GDK_WINDOW_TEMP:
case GDK_WINDOW_FOREIGN:
- if (!private->destroyed)
+ if (!private->drawable.destroyed)
{
if (private->parent)
{
parent_private->children = g_list_remove (parent_private->children, window);
}
- if (private->window_type != GDK_WINDOW_FOREIGN)
+ if (GDK_DRAWABLE_TYPE (window) != GDK_WINDOW_FOREIGN)
{
children = tmp = private->children;
private->children = NULL;
private->filters = NULL;
}
- if (private->window_type == GDK_WINDOW_FOREIGN)
+ if (private->drawable.window_type == GDK_WINDOW_FOREIGN)
{
if (our_destroy && (private->parent != NULL))
{
* OTOH, I don't think foreign windows are much
* used, so the question is maybe academic.
*/
- PostMessage (private->xwindow, WM_QUIT, 0, 0);
+ PostMessage (private->drawable.xwindow, WM_QUIT, 0, 0);
}
}
else if (xdestroy)
- DestroyWindow (private->xwindow);
+ DestroyWindow (private->drawable.xwindow);
- if (private->colormap)
- gdk_colormap_unref (private->colormap);
+ if (private->drawable.colormap)
+ gdk_colormap_unref (private->drawable.colormap);
private->mapped = FALSE;
- private->destroyed = TRUE;
+ private->drawable.destroyed = TRUE;
}
break;
g_error ("attempted to destroy root window");
break;
- case GDK_WINDOW_PIXMAP:
+ case GDK_DRAWABLE_PIXMAP:
g_error ("called gdk_window_destroy on a pixmap (use gdk_pixmap_unref)");
break;
}
void
gdk_window_destroy_notify (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
- private = (GdkWindowPrivate*) window;
-
GDK_NOTE (EVENTS, g_print ("gdk_window_destroy_notify: %#x %d\n",
- private->xwindow, private->destroyed));
+ GDK_DRAWABLE_XID (window), GDK_DRAWABLE_DESTROYED (window)));
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- if (private->window_type == GDK_WINDOW_FOREIGN)
- gdk_window_internal_destroy (window, FALSE, FALSE);
- else
- g_warning ("GdkWindow %#lx unexpectedly destroyed", private->xwindow);
+ if (GDK_DRAWABLE_TYPE(window) != GDK_WINDOW_FOREIGN)
+ g_warning ("GdkWindow %#lx unexpectedly destroyed", GDK_DRAWABLE_XID (window));
+
+ gdk_window_internal_destroy (window, FALSE, FALSE);
}
- gdk_xid_table_remove (private->xwindow);
+ gdk_xid_table_remove (GDK_DRAWABLE_XID (window));
gdk_window_unref (window);
}
{
GdkWindowPrivate *private = (GdkWindowPrivate *)window;
g_return_val_if_fail (window != NULL, NULL);
-
- private->ref_count += 1;
+
+ private->drawable.ref_count += 1;
GDK_NOTE (MISC, g_print ("gdk_window_ref %#x %d\n",
- private->xwindow, private->ref_count));
+ GDK_DRAWABLE_XID (window),
+ private->drawable.ref_count));
return window;
}
GdkWindowPrivate *private = (GdkWindowPrivate *)window;
g_return_if_fail (window != NULL);
- private->ref_count -= 1;
+ private->drawable.ref_count -= 1;
GDK_NOTE (MISC, g_print ("gdk_window_unref %#x %d%s\n",
- private->xwindow, private->ref_count,
- (private->ref_count == 0 ? " freeing" : "")));
+ private->drawable.xwindow,
+ private->drawable.ref_count,
+ (private->drawable.ref_count == 0 ? " freeing" : "")));
- if (private->ref_count == 0)
+ if (private->drawable.ref_count == 0)
{
- if (private->bg_type == GDK_WIN32_BG_PIXMAP && private->bg_pixmap != NULL)
+ if (private->bg_type == GDK_WIN32_BG_PIXMAP
+ && private->bg_pixmap != NULL)
gdk_pixmap_unref (private->bg_pixmap);
- if (!private->destroyed)
+ if (!private->drawable.destroyed)
{
- if (private->window_type == GDK_WINDOW_FOREIGN)
- gdk_xid_table_remove (private->xwindow);
+ if (private->drawable.window_type == GDK_WINDOW_FOREIGN)
+ gdk_xid_table_remove (private->drawable.xwindow);
else
g_warning ("losing last reference to undestroyed window");
}
g_return_if_fail (window != NULL);
private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ if (!private->drawable.destroyed)
{
- GDK_NOTE (MISC, g_print ("gdk_window_show: %#x\n", private->xwindow));
+ GDK_NOTE (MISC, g_print ("gdk_window_show: %#x\n",
+ private->drawable.xwindow));
private->mapped = TRUE;
- if (private->window_type == GDK_WINDOW_TEMP)
+ if (private->drawable.window_type == GDK_WINDOW_TEMP)
{
- ShowWindow (private->xwindow, SW_SHOWNOACTIVATE);
- SetWindowPos (private->xwindow, HWND_TOPMOST, 0, 0, 0, 0,
+ ShowWindow (private->drawable.xwindow, SW_SHOWNOACTIVATE);
+ SetWindowPos (private->drawable.xwindow, HWND_TOPMOST, 0, 0, 0, 0,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
#if 0
- ShowWindow (private->xwindow, SW_HIDE); /* Don't put on toolbar */
+ ShowWindow (private->drawable.xwindow, SW_HIDE); /* Don't put on toolbar */
#endif
}
else
{
- ShowWindow (private->xwindow, SW_SHOWNORMAL);
- ShowWindow (private->xwindow, SW_RESTORE);
- SetForegroundWindow (private->xwindow);
+ ShowWindow (private->drawable.xwindow, SW_SHOWNORMAL);
+ ShowWindow (private->drawable.xwindow, SW_RESTORE);
+ SetForegroundWindow (private->drawable.xwindow);
#if 0
- ShowOwnedPopups (private->xwindow, TRUE);
+ ShowOwnedPopups (private->drawable.xwindow, TRUE);
#endif
}
}
g_return_if_fail (window != NULL);
private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ if (!private->drawable.destroyed)
{
- GDK_NOTE (MISC, g_print ("gdk_window_hide: %#x\n", private->xwindow));
+ GDK_NOTE (MISC, g_print ("gdk_window_hide: %#x\n",
+ private->drawable.xwindow));
private->mapped = FALSE;
- if (private->window_type == GDK_WINDOW_TOPLEVEL)
- ShowOwnedPopups (private->xwindow, FALSE);
+ if (private->drawable.window_type == GDK_WINDOW_TOPLEVEL)
+ ShowOwnedPopups (private->drawable.xwindow, FALSE);
#if 1
- ShowWindow (private->xwindow, SW_HIDE);
+ ShowWindow (private->drawable.xwindow, SW_HIDE);
#elif 0
- ShowWindow (private->xwindow, SW_MINIMIZE);
+ ShowWindow (private->drawable.xwindow, SW_MINIMIZE);
#else
- CloseWindow (private->xwindow);
+ CloseWindow (private->drawable.xwindow);
#endif
}
}
g_return_if_fail (window != NULL);
private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ if (!private->drawable.destroyed)
{
- GDK_NOTE (MISC, g_print ("gdk_window_withdraw: %#x\n", private->xwindow));
+ GDK_NOTE (MISC, g_print ("gdk_window_withdraw: %#x\n",
+ private->drawable.xwindow));
gdk_window_hide (window); /* XXX */
}
g_return_if_fail (window != NULL);
private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ if (!private->drawable.destroyed)
{
RECT rect;
GDK_NOTE (MISC, g_print ("gdk_window_move: %#x +%d+%d\n",
- private->xwindow, x, y));
+ private->drawable.xwindow, x, y));
- GetClientRect (private->xwindow, &rect);
+ GetClientRect (private->drawable.xwindow, &rect);
- if (private->window_type != GDK_WINDOW_CHILD)
+ if (private->drawable.window_type != GDK_WINDOW_CHILD)
{
POINT ptTL, ptBR;
DWORD dwStyle;
ptTL.x = 0;
ptTL.y = 0;
- ClientToScreen (private->xwindow, &ptTL);
+ ClientToScreen (private->drawable.xwindow, &ptTL);
rect.left = x;
rect.top = y;
ptBR.x = rect.right;
ptBR.y = rect.bottom;
- ClientToScreen (private->xwindow, &ptBR);
+ ClientToScreen (private->drawable.xwindow, &ptBR);
rect.right = x + ptBR.x - ptTL.x;
rect.bottom = y + ptBR.y - ptTL.y;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
+ dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
if (!SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
g_warning ("gdk_window_move: AdjustWindowRectEx failed");
private->y = y;
}
GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
- private->xwindow,
+ private->drawable.xwindow,
rect.right - rect.left, rect.bottom - rect.top,
x, y));
- if (!MoveWindow (private->xwindow,
+ if (!MoveWindow (private->drawable.xwindow,
x, y, rect.right - rect.left, rect.bottom - rect.top,
TRUE))
g_warning ("gdk_window_move: MoveWindow failed");
private = (GdkWindowPrivate*) window;
- if (!private->destroyed &&
+ if (!private->drawable.destroyed &&
((private->resize_count > 0) ||
- (private->width != (guint16) width) ||
- (private->height != (guint16) height)))
+ (private->drawable.width != (guint16) width) ||
+ (private->drawable.height != (guint16) height)))
{
int x, y;
GDK_NOTE (MISC, g_print ("gdk_window_resize: %#x %dx%d\n",
- private->xwindow, width, height));
+ private->drawable.xwindow, width, height));
- if (private->window_type != GDK_WINDOW_CHILD)
+ if (private->drawable.window_type != GDK_WINDOW_CHILD)
{
POINT pt;
RECT rect;
pt.x = 0;
pt.y = 0;
- ClientToScreen (private->xwindow, &pt);
+ ClientToScreen (private->drawable.xwindow, &pt);
rect.left = pt.x;
rect.top = pt.y;
rect.right = pt.x + width;
rect.bottom = pt.y + height;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
+ dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
g_warning ("gdk_window_resize: AdjustWindowRectEx failed");
{
x = private->x;
y = private->y;
- private->width = width;
- private->height = height;
+ private->drawable.width = width;
+ private->drawable.height = height;
}
private->resize_count += 1;
GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
- private->xwindow, width, height, x, y));
- if (!MoveWindow (private->xwindow,
+ private->drawable.xwindow, width, height, x, y));
+ if (!MoveWindow (private->drawable.xwindow,
x, y, width, height,
TRUE))
g_warning ("gdk_window_resize: MoveWindow failed");
height = 1;
private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ if (!private->drawable.destroyed)
{
RECT rect;
DWORD dwStyle;
DWORD dwExStyle;
GDK_NOTE (MISC, g_print ("gdk_window_move_resize: %#x %dx%d@+%d+%d\n",
- private->xwindow, width, height, x, y));
+ private->drawable.xwindow, width, height, x, y));
rect.left = x;
rect.top = y;
rect.right = x + width;
rect.bottom = y + height;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
+ dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
g_warning ("gdk_window_move_resize: AdjustWindowRectEx failed");
- if (private->window_type == GDK_WINDOW_CHILD)
+ if (private->drawable.window_type == GDK_WINDOW_CHILD)
{
private->x = x;
private->y = y;
- private->width = width;
- private->height = height;
+ private->drawable.width = width;
+ private->drawable.height = height;
}
GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
- private->xwindow,
+ private->drawable.xwindow,
rect.right - rect.left, rect.bottom - rect.top,
rect.left, rect.top));
- if (!MoveWindow (private->xwindow,
+ if (!MoveWindow (private->drawable.xwindow,
rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top,
TRUE))
old_parent_private = (GdkWindowPrivate*)window_private->parent;
parent_private = (GdkWindowPrivate*) new_parent;
- if (!window_private->destroyed && !parent_private->destroyed)
+ if (!window_private->drawable.destroyed && !parent_private->drawable.destroyed)
{
GDK_NOTE (MISC, g_print ("gdk_window_reparent: %#x %#x\n",
- window_private->xwindow,
- parent_private->xwindow));
- if (!SetParent (window_private->xwindow, parent_private->xwindow))
+ window_private->drawable.xwindow,
+ parent_private->drawable.xwindow));
+ if (!SetParent (window_private->drawable.xwindow, parent_private->drawable.xwindow))
g_warning ("gdk_window_reparent: SetParent failed");
- if (!MoveWindow (window_private->xwindow,
+ if (!MoveWindow (window_private->drawable.xwindow,
x, y,
- window_private->width, window_private->height,
+ window_private->drawable.width, window_private->drawable.height,
TRUE))
g_warning ("gdk_window_reparent: MoveWindow failed");
}
void
gdk_window_clear (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
- {
- gdk_window_clear_area (window, 0, 0, private->width, private->height);
- }
+ if (!GDK_DRAWABLE_DESTROYED (window))
+ gdk_window_clear_area (window, 0, 0, -1, -1);
}
gint width,
gint height)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
HDC hdc;
if (height == -1)
height = G_MAXSHORT/2;
GDK_NOTE (MISC, g_print ("gdk_window_clear_area: %#x %dx%d@+%d+%d\n",
- private->xwindow, width, height, x, y));
- hdc = GetDC (private->xwindow);
+ GDK_DRAWABLE_XID (window), width, height, x, y));
+ hdc = GetDC (GDK_DRAWABLE_XID (window));
IntersectClipRect (hdc, x, y, x + width, y + height);
- SendMessage (private->xwindow, WM_ERASEBKGND, (WPARAM) hdc, 0);
- ReleaseDC (private->xwindow, hdc);
+ SendMessage (GDK_DRAWABLE_XID (window), WM_ERASEBKGND, (WPARAM) hdc, 0);
+ ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
}
}
gint width,
gint height)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
RECT rect;
GDK_NOTE (MISC, g_print ("gdk_window_clear_area_e: %#x %dx%d@+%d+%d\n",
- private->xwindow, width, height, x, y));
+ GDK_DRAWABLE_XID (window), width, height, x, y));
rect.left = x;
rect.right = x + width;
rect.top = y;
rect.bottom = y + height;
- if (!InvalidateRect (private->xwindow, &rect, TRUE))
+ if (!InvalidateRect (GDK_DRAWABLE_XID (window), &rect, TRUE))
g_warning ("gdk_window_clear_area_e: InvalidateRect failed");
- UpdateWindow (private->xwindow);
- }
-}
-
-void
-gdk_window_copy_area (GdkWindow *window,
- GdkGC *gc,
- gint x,
- gint y,
- GdkWindow *source_window,
- gint source_x,
- gint source_y,
- gint width,
- gint height)
-{
- GdkWindowPrivate *src_private;
- GdkWindowPrivate *dest_private;
- GdkGCPrivate *gc_private;
-
- g_return_if_fail (window != NULL);
- g_return_if_fail (gc != NULL);
-
- if (source_window == NULL)
- source_window = window;
-
- src_private = (GdkWindowPrivate*) source_window;
- dest_private = (GdkWindowPrivate*) window;
- gc_private = (GdkGCPrivate*) gc;
-
- if (!src_private->destroyed && !dest_private->destroyed)
- {
- HDC hdcDest, hdcSrc;
-
- if ((hdcDest = GetDC (dest_private->xwindow)) == NULL)
- g_warning ("gdk_window_copy_area: GetDC failed");
-
- if ((hdcSrc = GetDC (src_private->xwindow)) == NULL)
- g_warning ("gdk_window_copy_area: GetDC failed");
-
- if (!BitBlt (hdcDest, x, y, width, height, hdcSrc, source_x, source_y, SRCCOPY))
- g_warning ("gdk_window_copy_area: BitBlt failed");
-
- ReleaseDC (dest_private->xwindow, hdcDest);
- ReleaseDC (src_private->xwindow, hdcSrc);
+ UpdateWindow (GDK_DRAWABLE_XID (window));
}
}
void
gdk_window_raise (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- GDK_NOTE (MISC, g_print ("gdk_window_raise: %#x\n", private->xwindow));
+ GDK_NOTE (MISC, g_print ("gdk_window_raise: %#x\n",
+ GDK_DRAWABLE_XID (window)));
- if (!BringWindowToTop (private->xwindow))
+ if (!BringWindowToTop (GDK_DRAWABLE_XID (window)))
g_warning ("gdk_window_raise: BringWindowToTop failed");
}
}
void
gdk_window_lower (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- GDK_NOTE (MISC, g_print ("gdk_window_lower: %#x\n", private->xwindow));
+ GDK_NOTE (MISC, g_print ("gdk_window_lower: %#x\n",
+ GDK_DRAWABLE_XID (window)));
- if (!SetWindowPos (private->xwindow, HWND_BOTTOM, 0, 0, 0, 0,
+ if (!SetWindowPos (GDK_DRAWABLE_XID (window), HWND_BOTTOM, 0, 0, 0, 0,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE))
g_warning ("gdk_window_lower: SetWindowPos failed");
}
int diff;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
+ private = (GdkWindowPrivate*) window;
+
GDK_NOTE (MISC, g_print ("gdk_window_set_hints: %#x %dx%d..%dx%d @+%d+%d\n",
- private->xwindow,
+ private->drawable.xwindow,
min_width, min_height, max_width, max_height,
x, y));
if (flags)
{
if (flags & GDK_HINT_POS)
- if (!GetWindowPlacement (private->xwindow, &size_hints))
+ if (!GetWindowPlacement (private->drawable.xwindow, &size_hints))
g_warning ("gdk_window_set_hints: GetWindowPlacement failed");
else
{
rect.top = y;
rect.right = rect.left + 200; /* dummy */
rect.bottom = rect.top + 200;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
+ dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
size_hints.flags = 0;
size_hints.showCmd = SW_SHOWNA;
size_hints.rcNormalPosition.top,
size_hints.rcNormalPosition.right,
size_hints.rcNormalPosition.bottom));
- if (!SetWindowPlacement (private->xwindow, &size_hints))
+ if (!SetWindowPlacement (private->drawable.xwindow, &size_hints))
g_warning ("gdk_window_set_hints: SetWindowPlacement failed");
private->hint_x = rect.left;
private->hint_y = rect.top;
rect.top = 0;
rect.right = min_width;
rect.bottom = min_height;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
+ dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
private->hint_min_width = rect.right - rect.left;
private->hint_min_height = rect.bottom - rect.top;
/* Also chek if he current size of the window is in bounds. */
- GetClientRect (private->xwindow, &rect);
+ GetClientRect (private->drawable.xwindow, &rect);
if (rect.right < min_width && rect.bottom < min_height)
gdk_window_resize (window, min_width, min_height);
else if (rect.right < min_width)
rect.top = 0;
rect.right = max_width;
rect.bottom = max_height;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
+ dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
private->hint_max_width = rect.right - rect.left;
private->hint_max_height = rect.bottom - rect.top;
/* Again, check if the window is too large currently. */
- GetClientRect (private->xwindow, &rect);
+ GetClientRect (private->drawable.xwindow, &rect);
if (rect.right > max_width && rect.bottom > max_height)
gdk_window_resize (window, max_width, max_height);
else if (rect.right > max_width)
int diff;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
+
+ private = (GdkWindowPrivate*) window;
size_hints.length = sizeof (size_hints);
rect.top = 0;
rect.right = geometry->min_width;
rect.bottom = geometry->min_height;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
+ dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
private->hint_min_width = rect.right - rect.left;
private->hint_min_height = rect.bottom - rect.top;
/* Also check if he current size of the window is in bounds */
- GetClientRect (private->xwindow, &rect);
+ GetClientRect (private->drawable.xwindow, &rect);
if (rect.right < geometry->min_width
&& rect.bottom < geometry->min_height)
gdk_window_resize (window, geometry->min_width, geometry->min_height);
rect.top = 0;
rect.right = geometry->max_width;
rect.bottom = geometry->max_height;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
+ dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
private->hint_max_width = rect.right - rect.left;
private->hint_max_height = rect.bottom - rect.top;
/* Again, check if the window is too large currently. */
- GetClientRect (private->xwindow, &rect);
+ GetClientRect (private->drawable.xwindow, &rect);
if (rect.right > geometry->max_width
&& rect.bottom > geometry->max_height)
gdk_window_resize (window, geometry->max_width, geometry->max_height);
if (geom_mask & GDK_HINT_BASE_SIZE
&& geometry->base_width > 0
&& geometry->base_height > 0)
- if (!GetWindowPlacement (private->xwindow, &size_hints))
+ if (!GetWindowPlacement (private->drawable.xwindow, &size_hints))
g_warning ("gdk_window_set_hints: GetWindowPlacement failed");
else
{
size_hints.rcNormalPosition.top,
size_hints.rcNormalPosition.right,
size_hints.rcNormalPosition.bottom));
- if (!SetWindowPlacement (private->xwindow, &size_hints))
+ if (!SetWindowPlacement (private->drawable.xwindow, &size_hints))
g_warning ("gdk_window_set_hints: SetWindowPlacement failed");
}
gdk_window_set_title (GdkWindow *window,
const gchar *title)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
GDK_NOTE (MISC, g_print ("gdk_window_set_title: %#x %s\n",
- private->xwindow, title));
- if (!private->destroyed)
+ GDK_DRAWABLE_XID (window), title));
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- if (!SetWindowText (private->xwindow, title))
+ if (!SetWindowText (GDK_DRAWABLE_XID (window), title))
g_warning ("gdk_window_set_title: SetWindowText failed");
}
}
gdk_window_set_role (GdkWindow *window,
const gchar *role)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
GDK_NOTE (MISC, g_print ("gdk_window_set_role: %#x %s\n",
- private->xwindow, (role ? role : "NULL")));
+ GDK_DRAWABLE_XID (window), (role ? role : "NULL")));
/* XXX */
}
gdk_window_set_transient_for (GdkWindow *window,
GdkWindow *parent)
{
- GdkWindowPrivate *private;
- GdkWindowPrivate *parent_private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
- parent_private = (GdkWindowPrivate*) parent;
-
GDK_NOTE (MISC, g_print ("gdk_window_set_transient_for: %#x %#x\n",
- private->xwindow, parent_private->xwindow));
+ GDK_DRAWABLE_XID (window),
+ GDK_DRAWABLE_XID (parent)));
/* XXX */
}
GdkWindowPrivate *private;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- GdkColormapPrivate *colormap_private =
- (GdkColormapPrivate *) private->colormap;
-
GDK_NOTE (MISC, g_print ("gdk_window_set_background: %#x %s\n",
- private->xwindow,
+ private->drawable.xwindow,
gdk_color_to_string (color)));
if (private->bg_type == GDK_WIN32_BG_PIXMAP)
GdkPixmap *pixmap,
gint parent_relative)
{
- GdkWindowPrivate *window_private;
+ GdkWindowPrivate *private;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- window_private = (GdkWindowPrivate*) window;
+ private = (GdkWindowPrivate*) window;
- if (!window_private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- GdkColormapPrivate *colormap_private =
- (GdkColormapPrivate *) window_private->colormap;
- if (window_private->bg_type == GDK_WIN32_BG_PIXMAP)
+ if (private->bg_type == GDK_WIN32_BG_PIXMAP)
{
- if (window_private->bg_pixmap != NULL)
+ if (private->bg_pixmap != NULL)
{
- gdk_pixmap_unref (window_private->bg_pixmap);
- window_private->bg_pixmap = NULL;
+ gdk_pixmap_unref (private->bg_pixmap);
+ private->bg_pixmap = NULL;
}
- window_private->bg_type = GDK_WIN32_BG_NORMAL;
+ private->bg_type = GDK_WIN32_BG_NORMAL;
}
if (parent_relative)
{
- window_private->bg_type = GDK_WIN32_BG_PARENT_RELATIVE;
+ private->bg_type = GDK_WIN32_BG_PARENT_RELATIVE;
}
else if (!pixmap)
{
/* We must cache the pixmap in the WindowPrivate and
* paint it each time we get WM_ERASEBKGND
*/
- window_private->bg_type = GDK_WIN32_BG_PIXMAP;
- window_private->bg_pixmap = pixmap;
+ private->bg_type = GDK_WIN32_BG_PIXMAP;
+ private->bg_pixmap = pixmap;
gdk_pixmap_ref (pixmap);
}
}
HCURSOR xcursor;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
window_private = (GdkWindowPrivate*) window;
cursor_private = (GdkCursorPrivate*) cursor;
- if (!window_private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
if (!cursor)
xcursor = LoadCursor (NULL, IDC_ARROW);
xcursor = cursor_private->xcursor;
GDK_NOTE (MISC, g_print ("gdk_window_set_cursor: %#x %#x\n",
- window_private->xwindow, xcursor));
+ window_private->drawable.xwindow, xcursor));
window_private->xcursor = xcursor;
- SetCursor (xcursor);
- }
-}
-
-void
-gdk_window_set_colormap (GdkWindow *window,
- GdkColormap *colormap)
-{
- GdkWindowPrivate *window_private;
- GdkColormapPrivate *colormap_private;
-
- g_return_if_fail (window != NULL);
- g_return_if_fail (colormap != NULL);
-
- window_private = (GdkWindowPrivate*) window;
- colormap_private = (GdkColormapPrivate*) colormap;
-
- if (!window_private->destroyed)
- {
- /* XXX ??? */
- GDK_NOTE (MISC, g_print ("gdk_window_set_colormap: %#x %#x\n",
- window_private->xwindow,
- colormap_private->xcolormap));
- if (window_private->colormap)
- gdk_colormap_unref (window_private->colormap);
- window_private->colormap = colormap;
- gdk_colormap_ref (window_private->colormap);
-
- if (window_private->window_type != GDK_WINDOW_TOPLEVEL)
- gdk_window_add_colormap_windows (window);
}
}
gint *height,
gint *depth)
{
- GdkWindowPrivate *window_private;
+ g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
if (!window)
window = (GdkWindow*) &gdk_root_parent;
- window_private = (GdkWindowPrivate*) window;
-
- if (!window_private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
RECT rect;
- if (!GetClientRect (window_private->xwindow, &rect))
+ if (!GetClientRect (GDK_DRAWABLE_XID (window), &rect))
g_warning ("gdk_window_get_geometry: GetClientRect failed");
if (x)
if (height)
*height = rect.bottom - rect.top;
if (depth)
- *depth = gdk_window_get_visual (window)->depth;
+ *depth = gdk_drawable_get_visual (window)->depth;
}
}
GdkWindowPrivate *window_private;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
window_private = (GdkWindowPrivate*) window;
*y = window_private->y;
}
-void
-gdk_window_get_size (GdkWindow *window,
- gint *width,
- gint *height)
-{
- GdkWindowPrivate *window_private;
-
- g_return_if_fail (window != NULL);
-
- window_private = (GdkWindowPrivate*) window;
-
- if (width)
- *width = window_private->width;
- if (height)
- *height = window_private->height;
-}
-
-GdkVisual*
-gdk_window_get_visual (GdkWindow *window)
-{
- GdkWindowPrivate *window_private;
-
- g_return_val_if_fail (window != NULL, NULL);
-
- window_private = (GdkWindowPrivate*) window;
- /* Huh? ->parent is never set for a pixmap. We should just return
- * null immeditately. Well, do it then!
- */
- if (window_private->window_type == GDK_WINDOW_PIXMAP)
- return NULL;
-
- if (!window_private->destroyed)
- {
- if (window_private->colormap == NULL)
- return gdk_visual_get_system (); /* XXX ??? */
- else
- return ((GdkColormapPrivate *)window_private->colormap)->visual;
- }
-
- return NULL;
-}
-
-GdkColormap*
-gdk_window_get_colormap (GdkWindow *window)
-{
- GdkWindowPrivate *window_private;
-
- g_return_val_if_fail (window != NULL, NULL);
- window_private = (GdkWindowPrivate*) window;
-
- g_return_val_if_fail (window_private->window_type != GDK_WINDOW_PIXMAP, NULL);
- if (!window_private->destroyed)
- {
- if (window_private->colormap == NULL)
- return gdk_colormap_get_system (); /* XXX ??? */
- else
- return window_private->colormap;
- }
-
- return NULL;
-}
-
-GdkWindowType
-gdk_window_get_type (GdkWindow *window)
-{
- GdkWindowPrivate *window_private;
-
- g_return_val_if_fail (window != NULL, (GdkWindowType) -1);
-
- window_private = (GdkWindowPrivate*) window;
- return window_private->window_type;
-}
-
gint
gdk_window_get_origin (GdkWindow *window,
gint *x,
gint *y)
{
- GdkWindowPrivate *private;
gint return_val;
gint tx = 0;
gint ty = 0;
g_return_val_if_fail (window != NULL, 0);
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
POINT pt;
pt.x = 0;
pt.y = 0;
- ClientToScreen (private->xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
tx = pt.x;
ty = pt.y;
return_val = 1;
*y = ty;
GDK_NOTE (MISC, g_print ("gdk_window_get_origin: %#x: +%d+%d\n",
- private->xwindow, tx, ty));
+ GDK_DRAWABLE_XID (window), tx, ty));
return return_val;
}
POINT pt;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
private = (GdkWindowPrivate*) window;
if (x)
*x = 0;
if (y)
*y = 0;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
while (private->parent && ((GdkWindowPrivate*) private->parent)->parent)
private = (GdkWindowPrivate*) private->parent;
- if (private->destroyed)
+ if (private->drawable.destroyed)
return;
pt.x = 0;
pt.y = 0;
- ClientToScreen (private->xwindow, &pt);
+ ClientToScreen (private->drawable.xwindow, &pt);
if (x)
*x = pt.x;
if (y)
*y = pt.y;
GDK_NOTE (MISC, g_print ("gdk_window_get_root_origin: %#x: (%#x) +%d+%d\n",
- ((GdkWindowPrivate *) window)->xwindow,
- private->xwindow, pt.x, pt.y));
+ GDK_DRAWABLE_XID (window),
+ private->drawable.xwindow, pt.x, pt.y));
}
GdkWindow*
gint *y,
GdkModifierType *mask)
{
- GdkWindowPrivate *private;
GdkWindow *return_val;
POINT pointc, point;
HWND hwnd, hwndc;
+ g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
+
if (!window)
window = (GdkWindow*) &gdk_root_parent;
- private = (GdkWindowPrivate*) window;
-
return_val = NULL;
GetCursorPos (&pointc);
point = pointc;
- ScreenToClient (private->xwindow, &point);
+ ScreenToClient (GDK_DRAWABLE_XID (window), &point);
if (x)
*x = point.x;
gdk_window_at_pointer (gint *win_x,
gint *win_y)
{
- GdkWindowPrivate *private;
GdkWindow *window;
POINT point, pointc;
HWND hwnd, hwndc;
RECT rect;
- private = &gdk_root_parent;
-
GetCursorPos (&pointc);
point = pointc;
hwnd = WindowFromPoint (point);
gdk_window_get_parent (GdkWindow *window)
{
g_return_val_if_fail (window != NULL, NULL);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
return ((GdkWindowPrivate*) window)->parent;
}
GdkWindow*
gdk_window_get_toplevel (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_val_if_fail (window != NULL, NULL);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
- private = (GdkWindowPrivate*) window;
-
- while (private->window_type == GDK_WINDOW_CHILD)
- {
- window = ((GdkWindowPrivate*) window)->parent;
- private = (GdkWindowPrivate*) window;
- }
+ while (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_CHILD)
+ window = ((GdkWindowPrivate*) window)->parent;
return window;
}
GList *children;
g_return_val_if_fail (window != NULL, NULL);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return NULL;
/* XXX ??? */
- g_warning ("gdk_window_get_children ???");
+ g_warning ("gdk_window_get_children not implemented");
children = NULL;
return children;
GdkWindowPrivate *private;
g_return_val_if_fail (window != NULL, 0);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return 0;
return private->event_mask;
GdkWindowPrivate *private;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
private->event_mask = event_mask;
void
gdk_window_add_colormap_windows (GdkWindow *window)
{
- g_warning ("gdk_window_add_colormap_windows not implemented"); /* XXX */
+ g_warning ("gdk_window_add_colormap_windows not implemented");
}
-/*
- * This needs the X11 shape extension.
- * If not available, shaped windows will look
- * ugly, but programs still work. Stefan Wille
- */
void
gdk_window_shape_combine_mask (GdkWindow *window,
GdkBitmap *mask,
gint x, gint y)
{
- GdkWindowPrivate *window_private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- window_private = (GdkWindowPrivate*) window;
-
if (!mask)
{
GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %#x none\n",
- window_private->xwindow));
- SetWindowRgn (window_private->xwindow, NULL, TRUE);
+ GDK_DRAWABLE_XID (window)));
+ SetWindowRgn (GDK_DRAWABLE_XID (window), NULL, TRUE);
}
else
{
- GdkPixmapPrivate *pixmap_private;
+ GdkDrawablePrivate *pixmap_private;
HRGN hrgn;
DWORD dwStyle;
DWORD dwExStyle;
RECT rect;
/* Convert mask bitmap to region */
- pixmap_private = (GdkPixmapPrivate*) mask;
+ pixmap_private = (GdkDrawablePrivate*) mask;
hrgn = BitmapToRegion (pixmap_private->xwindow);
GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %#x %#x\n",
- window_private->xwindow,
+ GDK_DRAWABLE_XID (window),
pixmap_private->xwindow));
/* SetWindowRgn wants window (not client) coordinates */
- dwStyle = GetWindowLong (window_private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (window_private->xwindow, GWL_EXSTYLE);
- GetClientRect (window_private->xwindow, &rect);
+ dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+ dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
+ GetClientRect (GDK_DRAWABLE_XID (window), &rect);
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
OffsetRgn (hrgn, -rect.left, -rect.top);
OffsetRgn (hrgn, x, y);
/* If this is a top-level window, add the title bar to the region */
- if (window_private->window_type == GDK_WINDOW_TOPLEVEL)
+ if (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_TOPLEVEL)
{
CombineRgn (hrgn, hrgn,
CreateRectRgn (0, 0, rect.right - rect.left, -rect.top),
RGN_OR);
}
- SetWindowRgn (window_private->xwindow, hrgn, TRUE);
+ SetWindowRgn (GDK_DRAWABLE_XID (window), hrgn, TRUE);
}
}
GdkWindowPrivate *private;
GList *tmp_list;
GdkEventFilter *filter;
+
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
private = (GdkWindowPrivate*) window;
- if (private && private->destroyed)
+ if (private && GDK_DRAWABLE_DESTROYED (window))
return;
-
+
if (private)
tmp_list = private->filters;
else
tmp_list = gdk_default_filters;
-
+
while (tmp_list)
{
filter = (GdkEventFilter *)tmp_list->data;
return;
tmp_list = tmp_list->next;
}
-
+
filter = g_new (GdkEventFilter, 1);
filter->function = function;
filter->data = data;
-
+
if (private)
private->filters = g_list_append (private->filters, filter);
else
GdkWindowPrivate *private;
GList *tmp_list, *node;
GdkEventFilter *filter;
+
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
private = (GdkWindowPrivate*) window;
-
- if(private)
+
+ if (private)
tmp_list = private->filters;
else
tmp_list = gdk_default_filters;
-
+
while (tmp_list)
{
filter = (GdkEventFilter *)tmp_list->data;
node = tmp_list;
tmp_list = tmp_list->next;
-
+
if ((filter->function == function) && (filter->data == data))
{
- if(private)
+ if (private)
private->filters = g_list_remove_link (private->filters, node);
else
- gdk_default_filters = g_list_remove_link (gdk_default_filters, tmp_list);
+ gdk_default_filters = g_list_remove_link (gdk_default_filters, node);
g_list_free_1 (node);
g_free (filter);
gdk_window_set_override_redirect (GdkWindow *window,
gboolean override_redirect)
{
- g_warning ("gdk_window_set_override_redirect not implemented"); /* XXX */
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ g_warning ("gdk_window_set_override_redirect not implemented");
}
void
GdkPixmap *pixmap,
GdkBitmap *mask)
{
- g_warning ("gdk_window_set_icon not implemented"); /* XXX */
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ if (GDK_DRAWABLE_DESTROYED (window))
+ return;
+
+ g_warning ("gdk_window_set_icon not implemented");
}
-void
+void
gdk_window_set_icon_name (GdkWindow *window,
gchar *name)
{
- GdkWindowPrivate *window_private;
-
g_return_if_fail (window != NULL);
- window_private = (GdkWindowPrivate*) window;
- if (window_private->destroyed)
- return;
+ g_return_if_fail (GDK_IS_WINDOW (window));
- if (!SetWindowText (window_private->xwindow, name))
+ if (GDK_DRAWABLE_DESTROYED (window))
+ return;
+
+ if (!SetWindowText (GDK_DRAWABLE_XID (window), name))
g_warning ("gdk_window_set_icon_name: SetWindowText failed");
}
gdk_window_set_group (GdkWindow *window,
GdkWindow *leader)
{
- g_warning ("gdk_window_set_group not implemented"); /* XXX */
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+ g_return_if_fail (leader != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (leader));
+
+ if (GDK_DRAWABLE_DESTROYED (window) || GDK_DRAWABLE_DESTROYED (leader))
+ return;
+
+ g_warning ("gdk_window_set_group not implemented");
}
void
gdk_window_set_decorations (GdkWindow *window,
GdkWMDecoration decorations)
{
- GdkWindowPrivate *window_private = (GdkWindowPrivate *) window;
LONG style, exstyle;
- style = GetWindowLong (window_private->xwindow, GWL_STYLE);
- exstyle = GetWindowLong (window_private->xwindow, GWL_EXSTYLE);
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ style = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+ exstyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
style &= (WS_OVERLAPPED|WS_POPUP|WS_CHILD|WS_MINIMIZE|WS_VISIBLE|WS_DISABLED
|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZE);
if (decorations & GDK_DECOR_MAXIMIZE)
style |= (WS_MAXIMIZEBOX);
- SetWindowLong (window_private->xwindow, GWL_STYLE, style);
+ SetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE, style);
}
void
gdk_window_set_functions (GdkWindow *window,
GdkWMFunction functions)
{
- GdkWindowPrivate *window_private = (GdkWindowPrivate *) window;
LONG style, exstyle;
- style = GetWindowLong (window_private->xwindow, GWL_STYLE);
- exstyle = GetWindowLong (window_private->xwindow, GWL_EXSTYLE);
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ style = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+ exstyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
style &= (WS_OVERLAPPED|WS_POPUP|WS_CHILD|WS_MINIMIZE|WS_VISIBLE|WS_DISABLED
|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZE|WS_CAPTION|WS_BORDER
if (functions & GDK_FUNC_MAXIMIZE)
style |= (WS_MAXIMIZEBOX);
- SetWindowLong (window_private->xwindow, GWL_STYLE, style);
+ SetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE, style);
}
GList *
void
gdk_window_set_child_shapes (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
- gdk_propagate_shapes ( private->xwindow, FALSE);
+ gdk_propagate_shapes (GDK_DRAWABLE_XID (window), FALSE);
}
void
gdk_window_merge_child_shapes (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
- gdk_propagate_shapes (private->xwindow, TRUE);
+ gdk_propagate_shapes (GDK_DRAWABLE_XID (window), TRUE);
}
/*************************************************************
GdkWindowPrivate *private = (GdkWindowPrivate *)window;
g_return_val_if_fail (window != NULL, FALSE);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
return private->mapped;
}
GdkWindowPrivate *private = (GdkWindowPrivate *)window;
g_return_val_if_fail (window != NULL, FALSE);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
while (private &&
(private != &gdk_root_parent) &&
- (private->window_type != GDK_WINDOW_FOREIGN))
+ (private->drawable.window_type != GDK_WINDOW_FOREIGN))
{
if (!private->mapped)
return FALSE;
return TRUE;
}
-void
-gdk_drawable_set_data (GdkDrawable *drawable,
- const gchar *key,
- gpointer data,
- GDestroyNotify destroy_func)
-{
- g_dataset_set_data_full (drawable, key, data, destroy_func);
-}
-
-
/* Support for windows that can be guffaw-scrolled
* (See http://www.gtk.org/~otaylor/whitepapers/guffaw-scrolling.txt)
*/
{
enum { UNKNOWN, NO, YES };
static gint gravity_works = UNKNOWN;
-
+
if (gravity_works == UNKNOWN)
{
GdkWindowAttr attr;
attr.window_type = GDK_WINDOW_CHILD;
child = gdk_window_new (parent, &attr, GDK_WA_X | GDK_WA_Y);
-
+
gdk_window_set_static_win_gravity (child, TRUE);
gdk_window_resize (parent, 100, 110);
gdk_window_destroy (parent);
gdk_window_destroy (child);
-
+
gravity_works = ((y == -20) ? YES : NO);
}
-
+
return (gravity_works == YES);
}
static void
gdk_window_set_static_bit_gravity (GdkWindow *window, gboolean on)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-
g_return_if_fail (window != NULL);
- GDK_NOTE (MISC,
- g_print ("gdk_window_set_static_bit_gravity: Not implemented\n"));
+ GDK_NOTE (MISC, g_print ("gdk_window_set_static_bit_gravity: Not implemented\n"));
}
static void
gdk_window_set_static_win_gravity (GdkWindow *window, gboolean on)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-
g_return_if_fail (window != NULL);
GDK_NOTE (MISC,
{
GdkWindowPrivate *private = (GdkWindowPrivate *)window;
GList *tmp_list;
-
- g_return_val_if_fail (window != NULL, FALSE);
+ g_return_val_if_fail (window != NULL, FALSE);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
+
if (!use_static == !private->guffaw_gravity)
return TRUE;
if (use_static && !gdk_window_gravity_works ())
return FALSE;
-
+
private->guffaw_gravity = use_static;
-
- gdk_window_set_static_bit_gravity (window, use_static);
-
- tmp_list = private->children;
- while (tmp_list)
+
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- gdk_window_set_static_win_gravity (window, use_static);
+ gdk_window_set_static_bit_gravity (window, use_static);
- tmp_list = tmp_list->next;
+ tmp_list = private->children;
+ while (tmp_list)
+ {
+ gdk_window_set_static_win_gravity (window, use_static);
+
+ tmp_list = tmp_list->next;
+ }
}
-
+
return TRUE;
}
#include "gdkwindow.h"
#include "gdkprivate.h"
#include "gdkinputprivate.h"
+#include "gdkx.h"
/* The Win API function AdjustWindowRect may return negative values
* resulting in obscured title bars. This helper function is coreccting it.
}
#endif
- gdk_root_parent.xwindow = gdk_root_window;
- gdk_root_parent.window_type = GDK_WINDOW_ROOT;
- gdk_root_parent.window.user_data = NULL;
- gdk_root_parent.width = width;
- gdk_root_parent.height = height;
+ gdk_root_parent.drawable.xwindow = gdk_root_window;
+ gdk_root_parent.drawable.window_type = GDK_WINDOW_ROOT;
+ gdk_root_parent.drawable.drawable.user_data = NULL;
+ gdk_root_parent.drawable.width = width;
+ gdk_root_parent.drawable.height = height;
+ gdk_root_parent.drawable.ref_count = 1;
+ gdk_root_parent.drawable.colormap = NULL;
gdk_root_parent.children = NULL;
- gdk_root_parent.colormap = NULL;
- gdk_root_parent.ref_count = 1;
gdk_xid_table_insert (&gdk_root_window, &gdk_root_parent);
}
case GDK_WINDOW_ROOT:
g_error ("cannot make windows of type GDK_WINDOW_ROOT");
break;
- case GDK_WINDOW_PIXMAP:
- g_error ("cannot make windows of type GDK_WINDOW_PIXMAP (use gdk_pixmap_new)");
+ case GDK_DRAWABLE_PIXMAP:
+ g_error ("cannot make windows of type GDK_DRAWABLE_PIXMAP (use gdk_pixmap_new)");
break;
}
parent = (GdkWindow*) &gdk_root_parent;
parent_private = (GdkWindowPrivate*) parent;
- if (parent_private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (parent))
return NULL;
- xparent = parent_private->xwindow;
+ xparent = parent_private->drawable.xwindow;
private = g_new (GdkWindowPrivate, 1);
window = (GdkWindow*) private;
private->parent = parent;
- private->destroyed = FALSE;
+ private->drawable.destroyed = FALSE;
private->mapped = FALSE;
private->guffaw_gravity = FALSE;
private->resize_count = 0;
- private->ref_count = 1;
+ private->drawable.ref_count = 1;
private->x = (attributes_mask & GDK_WA_X) ? attributes->x : 0;
private->y = (attributes_mask & GDK_WA_Y) ? attributes->y : 0;
- private->width = (attributes->width > 1) ? (attributes->width) : (1);
- private->height = (attributes->height > 1) ? (attributes->height) : (1);
- private->window_type = attributes->window_type;
+ private->drawable.width = (attributes->width > 1) ? (attributes->width) : (1);
+ private->drawable.height = (attributes->height > 1) ? (attributes->height) : (1);
+ private->drawable.window_type = attributes->window_type;
private->extension_events = 0;
private->extension_events_selected = FALSE;
{
dwExStyle = 0;
if (attributes_mask & GDK_WA_COLORMAP)
- private->colormap = attributes->colormap;
+ private->drawable.colormap = attributes->colormap;
else
- private->colormap = gdk_colormap_get_system ();
+ private->drawable.colormap = gdk_colormap_get_system ();
}
else
{
dwExStyle = WS_EX_TRANSPARENT;
- private->colormap = NULL;
+ private->drawable.colormap = NULL;
private->bg_type = GDK_WIN32_BG_TRANSPARENT;
private->bg_pixmap = NULL;
}
if (parent_private)
parent_private->children = g_list_prepend (parent_private->children, window);
- switch (private->window_type)
+ switch (private->drawable.window_type)
{
case GDK_WINDOW_TOPLEVEL:
dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN;
case GDK_WINDOW_ROOT:
g_error ("cannot make windows of type GDK_WINDOW_ROOT");
break;
- case GDK_WINDOW_PIXMAP:
- g_error ("cannot make windows of type GDK_WINDOW_PIXMAP (use gdk_pixmap_new)");
+ case GDK_DRAWABLE_PIXMAP:
+ g_error ("cannot make windows of type GDK_DRAWABLE_PIXMAP (use gdk_pixmap_new)");
break;
}
- klass = RegisterGdkClass (private->window_type);
+ klass = RegisterGdkClass (private->drawable.window_type);
if (!klass)
g_error ("RegisterClassEx failed");
- if (private->window_type != GDK_WINDOW_CHILD)
+ if (private->drawable.window_type != GDK_WINDOW_CHILD)
{
if (x == CW_USEDEFAULT)
{
rect.top = y;
}
- rect.right = rect.left + private->width;
- rect.bottom = rect.top + private->height;
+ rect.right = rect.left + private->drawable.width;
+ rect.bottom = rect.top + private->drawable.height;
if (!SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
g_warning ("gdk_window_new: AdjustWindowRectEx failed");
}
else
{
- width = private->width;
- height = private->height;
+ width = private->drawable.width;
+ height = private->drawable.height;
}
- private->xwindow =
+ private->drawable.xwindow =
CreateWindowEx (dwExStyle,
MAKEINTRESOURCE(klass),
title,
NULL);
GDK_NOTE (MISC,
g_print ("gdk_window_create: %s %s %#x %#x %dx%d@+%d+%d %#x = %#x\n",
- (private->window_type == GDK_WINDOW_TOPLEVEL ? "TOPLEVEL" :
- (private->window_type == GDK_WINDOW_CHILD ? "CHILD" :
- (private->window_type == GDK_WINDOW_DIALOG ? "DIALOG" :
- (private->window_type == GDK_WINDOW_TEMP ? "TEMP" :
+ (private->drawable.window_type == GDK_WINDOW_TOPLEVEL ? "TOPLEVEL" :
+ (private->drawable.window_type == GDK_WINDOW_CHILD ? "CHILD" :
+ (private->drawable.window_type == GDK_WINDOW_DIALOG ? "DIALOG" :
+ (private->drawable.window_type == GDK_WINDOW_TEMP ? "TEMP" :
"???")))),
title,
dwStyle,
private->event_mask,
width, height, (x == CW_USEDEFAULT ? -9999 : x), y,
xparent,
- private->xwindow));
+ private->drawable.xwindow));
gdk_window_ref (window);
- gdk_xid_table_insert (&private->xwindow, window);
+ gdk_xid_table_insert (&private->drawable.xwindow, window);
- if (private->colormap)
- gdk_colormap_ref (private->colormap);
+ if (private->drawable.colormap)
+ gdk_colormap_ref (private->drawable.colormap);
gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
(attributes->cursor) :
if (parent_private)
parent_private->children = g_list_prepend (parent_private->children, window);
- private->xwindow = (HWND) anid;
+ private->drawable.xwindow = (HWND) anid;
GetClientRect ((HWND) anid, &rect);
point.x = rect.left;
point.y = rect.right;
ScreenToClient (parent, &point);
private->x = point.x;
private->y = point.y;
- private->width = rect.right - rect.left;
- private->height = rect.bottom - rect.top;
+ private->drawable.width = rect.right - rect.left;
+ private->drawable.height = rect.bottom - rect.top;
private->resize_count = 0;
- private->ref_count = 1;
- private->window_type = GDK_WINDOW_FOREIGN;
- private->destroyed = FALSE;
- private->mapped = IsWindowVisible (private->xwindow);
+ private->drawable.ref_count = 1;
+ private->drawable.window_type = GDK_WINDOW_FOREIGN;
+ private->drawable.destroyed = FALSE;
+ private->mapped = IsWindowVisible (private->drawable.xwindow);
private->guffaw_gravity = FALSE;
private->extension_events = 0;
private->extension_events_selected = FALSE;
- private->colormap = NULL;
+ private->drawable.colormap = NULL;
private->filters = NULL;
private->children = NULL;
window->user_data = NULL;
gdk_window_ref (window);
- gdk_xid_table_insert (&private->xwindow, window);
+ gdk_xid_table_insert (&private->drawable.xwindow, window);
return window;
}
private = (GdkWindowPrivate*) window;
GDK_NOTE (MISC, g_print ("gdk_window_internal_destroy %#x\n",
- private->xwindow));
+ private->drawable.xwindow));
- switch (private->window_type)
+ switch (private->drawable.window_type)
{
case GDK_WINDOW_TOPLEVEL:
case GDK_WINDOW_CHILD:
case GDK_WINDOW_DIALOG:
case GDK_WINDOW_TEMP:
case GDK_WINDOW_FOREIGN:
- if (!private->destroyed)
+ if (!private->drawable.destroyed)
{
if (private->parent)
{
parent_private->children = g_list_remove (parent_private->children, window);
}
- if (private->window_type != GDK_WINDOW_FOREIGN)
+ if (GDK_DRAWABLE_TYPE (window) != GDK_WINDOW_FOREIGN)
{
children = tmp = private->children;
private->children = NULL;
private->filters = NULL;
}
- if (private->window_type == GDK_WINDOW_FOREIGN)
+ if (private->drawable.window_type == GDK_WINDOW_FOREIGN)
{
if (our_destroy && (private->parent != NULL))
{
* OTOH, I don't think foreign windows are much
* used, so the question is maybe academic.
*/
- PostMessage (private->xwindow, WM_QUIT, 0, 0);
+ PostMessage (private->drawable.xwindow, WM_QUIT, 0, 0);
}
}
else if (xdestroy)
- DestroyWindow (private->xwindow);
+ DestroyWindow (private->drawable.xwindow);
- if (private->colormap)
- gdk_colormap_unref (private->colormap);
+ if (private->drawable.colormap)
+ gdk_colormap_unref (private->drawable.colormap);
private->mapped = FALSE;
- private->destroyed = TRUE;
+ private->drawable.destroyed = TRUE;
}
break;
g_error ("attempted to destroy root window");
break;
- case GDK_WINDOW_PIXMAP:
+ case GDK_DRAWABLE_PIXMAP:
g_error ("called gdk_window_destroy on a pixmap (use gdk_pixmap_unref)");
break;
}
void
gdk_window_destroy_notify (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
- private = (GdkWindowPrivate*) window;
-
GDK_NOTE (EVENTS, g_print ("gdk_window_destroy_notify: %#x %d\n",
- private->xwindow, private->destroyed));
+ GDK_DRAWABLE_XID (window), GDK_DRAWABLE_DESTROYED (window)));
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- if (private->window_type == GDK_WINDOW_FOREIGN)
- gdk_window_internal_destroy (window, FALSE, FALSE);
- else
- g_warning ("GdkWindow %#lx unexpectedly destroyed", private->xwindow);
+ if (GDK_DRAWABLE_TYPE(window) != GDK_WINDOW_FOREIGN)
+ g_warning ("GdkWindow %#lx unexpectedly destroyed", GDK_DRAWABLE_XID (window));
+
+ gdk_window_internal_destroy (window, FALSE, FALSE);
}
- gdk_xid_table_remove (private->xwindow);
+ gdk_xid_table_remove (GDK_DRAWABLE_XID (window));
gdk_window_unref (window);
}
{
GdkWindowPrivate *private = (GdkWindowPrivate *)window;
g_return_val_if_fail (window != NULL, NULL);
-
- private->ref_count += 1;
+
+ private->drawable.ref_count += 1;
GDK_NOTE (MISC, g_print ("gdk_window_ref %#x %d\n",
- private->xwindow, private->ref_count));
+ GDK_DRAWABLE_XID (window),
+ private->drawable.ref_count));
return window;
}
GdkWindowPrivate *private = (GdkWindowPrivate *)window;
g_return_if_fail (window != NULL);
- private->ref_count -= 1;
+ private->drawable.ref_count -= 1;
GDK_NOTE (MISC, g_print ("gdk_window_unref %#x %d%s\n",
- private->xwindow, private->ref_count,
- (private->ref_count == 0 ? " freeing" : "")));
+ private->drawable.xwindow,
+ private->drawable.ref_count,
+ (private->drawable.ref_count == 0 ? " freeing" : "")));
- if (private->ref_count == 0)
+ if (private->drawable.ref_count == 0)
{
- if (private->bg_type == GDK_WIN32_BG_PIXMAP && private->bg_pixmap != NULL)
+ if (private->bg_type == GDK_WIN32_BG_PIXMAP
+ && private->bg_pixmap != NULL)
gdk_pixmap_unref (private->bg_pixmap);
- if (!private->destroyed)
+ if (!private->drawable.destroyed)
{
- if (private->window_type == GDK_WINDOW_FOREIGN)
- gdk_xid_table_remove (private->xwindow);
+ if (private->drawable.window_type == GDK_WINDOW_FOREIGN)
+ gdk_xid_table_remove (private->drawable.xwindow);
else
g_warning ("losing last reference to undestroyed window");
}
g_return_if_fail (window != NULL);
private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ if (!private->drawable.destroyed)
{
- GDK_NOTE (MISC, g_print ("gdk_window_show: %#x\n", private->xwindow));
+ GDK_NOTE (MISC, g_print ("gdk_window_show: %#x\n",
+ private->drawable.xwindow));
private->mapped = TRUE;
- if (private->window_type == GDK_WINDOW_TEMP)
+ if (private->drawable.window_type == GDK_WINDOW_TEMP)
{
- ShowWindow (private->xwindow, SW_SHOWNOACTIVATE);
- SetWindowPos (private->xwindow, HWND_TOPMOST, 0, 0, 0, 0,
+ ShowWindow (private->drawable.xwindow, SW_SHOWNOACTIVATE);
+ SetWindowPos (private->drawable.xwindow, HWND_TOPMOST, 0, 0, 0, 0,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
#if 0
- ShowWindow (private->xwindow, SW_HIDE); /* Don't put on toolbar */
+ ShowWindow (private->drawable.xwindow, SW_HIDE); /* Don't put on toolbar */
#endif
}
else
{
- ShowWindow (private->xwindow, SW_SHOWNORMAL);
- ShowWindow (private->xwindow, SW_RESTORE);
- SetForegroundWindow (private->xwindow);
+ ShowWindow (private->drawable.xwindow, SW_SHOWNORMAL);
+ ShowWindow (private->drawable.xwindow, SW_RESTORE);
+ SetForegroundWindow (private->drawable.xwindow);
#if 0
- ShowOwnedPopups (private->xwindow, TRUE);
+ ShowOwnedPopups (private->drawable.xwindow, TRUE);
#endif
}
}
g_return_if_fail (window != NULL);
private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ if (!private->drawable.destroyed)
{
- GDK_NOTE (MISC, g_print ("gdk_window_hide: %#x\n", private->xwindow));
+ GDK_NOTE (MISC, g_print ("gdk_window_hide: %#x\n",
+ private->drawable.xwindow));
private->mapped = FALSE;
- if (private->window_type == GDK_WINDOW_TOPLEVEL)
- ShowOwnedPopups (private->xwindow, FALSE);
+ if (private->drawable.window_type == GDK_WINDOW_TOPLEVEL)
+ ShowOwnedPopups (private->drawable.xwindow, FALSE);
#if 1
- ShowWindow (private->xwindow, SW_HIDE);
+ ShowWindow (private->drawable.xwindow, SW_HIDE);
#elif 0
- ShowWindow (private->xwindow, SW_MINIMIZE);
+ ShowWindow (private->drawable.xwindow, SW_MINIMIZE);
#else
- CloseWindow (private->xwindow);
+ CloseWindow (private->drawable.xwindow);
#endif
}
}
g_return_if_fail (window != NULL);
private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ if (!private->drawable.destroyed)
{
- GDK_NOTE (MISC, g_print ("gdk_window_withdraw: %#x\n", private->xwindow));
+ GDK_NOTE (MISC, g_print ("gdk_window_withdraw: %#x\n",
+ private->drawable.xwindow));
gdk_window_hide (window); /* XXX */
}
g_return_if_fail (window != NULL);
private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ if (!private->drawable.destroyed)
{
RECT rect;
GDK_NOTE (MISC, g_print ("gdk_window_move: %#x +%d+%d\n",
- private->xwindow, x, y));
+ private->drawable.xwindow, x, y));
- GetClientRect (private->xwindow, &rect);
+ GetClientRect (private->drawable.xwindow, &rect);
- if (private->window_type != GDK_WINDOW_CHILD)
+ if (private->drawable.window_type != GDK_WINDOW_CHILD)
{
POINT ptTL, ptBR;
DWORD dwStyle;
ptTL.x = 0;
ptTL.y = 0;
- ClientToScreen (private->xwindow, &ptTL);
+ ClientToScreen (private->drawable.xwindow, &ptTL);
rect.left = x;
rect.top = y;
ptBR.x = rect.right;
ptBR.y = rect.bottom;
- ClientToScreen (private->xwindow, &ptBR);
+ ClientToScreen (private->drawable.xwindow, &ptBR);
rect.right = x + ptBR.x - ptTL.x;
rect.bottom = y + ptBR.y - ptTL.y;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
+ dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
if (!SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
g_warning ("gdk_window_move: AdjustWindowRectEx failed");
private->y = y;
}
GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
- private->xwindow,
+ private->drawable.xwindow,
rect.right - rect.left, rect.bottom - rect.top,
x, y));
- if (!MoveWindow (private->xwindow,
+ if (!MoveWindow (private->drawable.xwindow,
x, y, rect.right - rect.left, rect.bottom - rect.top,
TRUE))
g_warning ("gdk_window_move: MoveWindow failed");
private = (GdkWindowPrivate*) window;
- if (!private->destroyed &&
+ if (!private->drawable.destroyed &&
((private->resize_count > 0) ||
- (private->width != (guint16) width) ||
- (private->height != (guint16) height)))
+ (private->drawable.width != (guint16) width) ||
+ (private->drawable.height != (guint16) height)))
{
int x, y;
GDK_NOTE (MISC, g_print ("gdk_window_resize: %#x %dx%d\n",
- private->xwindow, width, height));
+ private->drawable.xwindow, width, height));
- if (private->window_type != GDK_WINDOW_CHILD)
+ if (private->drawable.window_type != GDK_WINDOW_CHILD)
{
POINT pt;
RECT rect;
pt.x = 0;
pt.y = 0;
- ClientToScreen (private->xwindow, &pt);
+ ClientToScreen (private->drawable.xwindow, &pt);
rect.left = pt.x;
rect.top = pt.y;
rect.right = pt.x + width;
rect.bottom = pt.y + height;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
+ dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
g_warning ("gdk_window_resize: AdjustWindowRectEx failed");
{
x = private->x;
y = private->y;
- private->width = width;
- private->height = height;
+ private->drawable.width = width;
+ private->drawable.height = height;
}
private->resize_count += 1;
GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
- private->xwindow, width, height, x, y));
- if (!MoveWindow (private->xwindow,
+ private->drawable.xwindow, width, height, x, y));
+ if (!MoveWindow (private->drawable.xwindow,
x, y, width, height,
TRUE))
g_warning ("gdk_window_resize: MoveWindow failed");
height = 1;
private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ if (!private->drawable.destroyed)
{
RECT rect;
DWORD dwStyle;
DWORD dwExStyle;
GDK_NOTE (MISC, g_print ("gdk_window_move_resize: %#x %dx%d@+%d+%d\n",
- private->xwindow, width, height, x, y));
+ private->drawable.xwindow, width, height, x, y));
rect.left = x;
rect.top = y;
rect.right = x + width;
rect.bottom = y + height;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
+ dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
g_warning ("gdk_window_move_resize: AdjustWindowRectEx failed");
- if (private->window_type == GDK_WINDOW_CHILD)
+ if (private->drawable.window_type == GDK_WINDOW_CHILD)
{
private->x = x;
private->y = y;
- private->width = width;
- private->height = height;
+ private->drawable.width = width;
+ private->drawable.height = height;
}
GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
- private->xwindow,
+ private->drawable.xwindow,
rect.right - rect.left, rect.bottom - rect.top,
rect.left, rect.top));
- if (!MoveWindow (private->xwindow,
+ if (!MoveWindow (private->drawable.xwindow,
rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top,
TRUE))
old_parent_private = (GdkWindowPrivate*)window_private->parent;
parent_private = (GdkWindowPrivate*) new_parent;
- if (!window_private->destroyed && !parent_private->destroyed)
+ if (!window_private->drawable.destroyed && !parent_private->drawable.destroyed)
{
GDK_NOTE (MISC, g_print ("gdk_window_reparent: %#x %#x\n",
- window_private->xwindow,
- parent_private->xwindow));
- if (!SetParent (window_private->xwindow, parent_private->xwindow))
+ window_private->drawable.xwindow,
+ parent_private->drawable.xwindow));
+ if (!SetParent (window_private->drawable.xwindow, parent_private->drawable.xwindow))
g_warning ("gdk_window_reparent: SetParent failed");
- if (!MoveWindow (window_private->xwindow,
+ if (!MoveWindow (window_private->drawable.xwindow,
x, y,
- window_private->width, window_private->height,
+ window_private->drawable.width, window_private->drawable.height,
TRUE))
g_warning ("gdk_window_reparent: MoveWindow failed");
}
void
gdk_window_clear (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
- {
- gdk_window_clear_area (window, 0, 0, private->width, private->height);
- }
+ if (!GDK_DRAWABLE_DESTROYED (window))
+ gdk_window_clear_area (window, 0, 0, -1, -1);
}
gint width,
gint height)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
HDC hdc;
if (height == -1)
height = G_MAXSHORT/2;
GDK_NOTE (MISC, g_print ("gdk_window_clear_area: %#x %dx%d@+%d+%d\n",
- private->xwindow, width, height, x, y));
- hdc = GetDC (private->xwindow);
+ GDK_DRAWABLE_XID (window), width, height, x, y));
+ hdc = GetDC (GDK_DRAWABLE_XID (window));
IntersectClipRect (hdc, x, y, x + width, y + height);
- SendMessage (private->xwindow, WM_ERASEBKGND, (WPARAM) hdc, 0);
- ReleaseDC (private->xwindow, hdc);
+ SendMessage (GDK_DRAWABLE_XID (window), WM_ERASEBKGND, (WPARAM) hdc, 0);
+ ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
}
}
gint width,
gint height)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
RECT rect;
GDK_NOTE (MISC, g_print ("gdk_window_clear_area_e: %#x %dx%d@+%d+%d\n",
- private->xwindow, width, height, x, y));
+ GDK_DRAWABLE_XID (window), width, height, x, y));
rect.left = x;
rect.right = x + width;
rect.top = y;
rect.bottom = y + height;
- if (!InvalidateRect (private->xwindow, &rect, TRUE))
+ if (!InvalidateRect (GDK_DRAWABLE_XID (window), &rect, TRUE))
g_warning ("gdk_window_clear_area_e: InvalidateRect failed");
- UpdateWindow (private->xwindow);
- }
-}
-
-void
-gdk_window_copy_area (GdkWindow *window,
- GdkGC *gc,
- gint x,
- gint y,
- GdkWindow *source_window,
- gint source_x,
- gint source_y,
- gint width,
- gint height)
-{
- GdkWindowPrivate *src_private;
- GdkWindowPrivate *dest_private;
- GdkGCPrivate *gc_private;
-
- g_return_if_fail (window != NULL);
- g_return_if_fail (gc != NULL);
-
- if (source_window == NULL)
- source_window = window;
-
- src_private = (GdkWindowPrivate*) source_window;
- dest_private = (GdkWindowPrivate*) window;
- gc_private = (GdkGCPrivate*) gc;
-
- if (!src_private->destroyed && !dest_private->destroyed)
- {
- HDC hdcDest, hdcSrc;
-
- if ((hdcDest = GetDC (dest_private->xwindow)) == NULL)
- g_warning ("gdk_window_copy_area: GetDC failed");
-
- if ((hdcSrc = GetDC (src_private->xwindow)) == NULL)
- g_warning ("gdk_window_copy_area: GetDC failed");
-
- if (!BitBlt (hdcDest, x, y, width, height, hdcSrc, source_x, source_y, SRCCOPY))
- g_warning ("gdk_window_copy_area: BitBlt failed");
-
- ReleaseDC (dest_private->xwindow, hdcDest);
- ReleaseDC (src_private->xwindow, hdcSrc);
+ UpdateWindow (GDK_DRAWABLE_XID (window));
}
}
void
gdk_window_raise (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- GDK_NOTE (MISC, g_print ("gdk_window_raise: %#x\n", private->xwindow));
+ GDK_NOTE (MISC, g_print ("gdk_window_raise: %#x\n",
+ GDK_DRAWABLE_XID (window)));
- if (!BringWindowToTop (private->xwindow))
+ if (!BringWindowToTop (GDK_DRAWABLE_XID (window)))
g_warning ("gdk_window_raise: BringWindowToTop failed");
}
}
void
gdk_window_lower (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- GDK_NOTE (MISC, g_print ("gdk_window_lower: %#x\n", private->xwindow));
+ GDK_NOTE (MISC, g_print ("gdk_window_lower: %#x\n",
+ GDK_DRAWABLE_XID (window)));
- if (!SetWindowPos (private->xwindow, HWND_BOTTOM, 0, 0, 0, 0,
+ if (!SetWindowPos (GDK_DRAWABLE_XID (window), HWND_BOTTOM, 0, 0, 0, 0,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE))
g_warning ("gdk_window_lower: SetWindowPos failed");
}
int diff;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
+ private = (GdkWindowPrivate*) window;
+
GDK_NOTE (MISC, g_print ("gdk_window_set_hints: %#x %dx%d..%dx%d @+%d+%d\n",
- private->xwindow,
+ private->drawable.xwindow,
min_width, min_height, max_width, max_height,
x, y));
if (flags)
{
if (flags & GDK_HINT_POS)
- if (!GetWindowPlacement (private->xwindow, &size_hints))
+ if (!GetWindowPlacement (private->drawable.xwindow, &size_hints))
g_warning ("gdk_window_set_hints: GetWindowPlacement failed");
else
{
rect.top = y;
rect.right = rect.left + 200; /* dummy */
rect.bottom = rect.top + 200;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
+ dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
size_hints.flags = 0;
size_hints.showCmd = SW_SHOWNA;
size_hints.rcNormalPosition.top,
size_hints.rcNormalPosition.right,
size_hints.rcNormalPosition.bottom));
- if (!SetWindowPlacement (private->xwindow, &size_hints))
+ if (!SetWindowPlacement (private->drawable.xwindow, &size_hints))
g_warning ("gdk_window_set_hints: SetWindowPlacement failed");
private->hint_x = rect.left;
private->hint_y = rect.top;
rect.top = 0;
rect.right = min_width;
rect.bottom = min_height;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
+ dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
private->hint_min_width = rect.right - rect.left;
private->hint_min_height = rect.bottom - rect.top;
/* Also chek if he current size of the window is in bounds. */
- GetClientRect (private->xwindow, &rect);
+ GetClientRect (private->drawable.xwindow, &rect);
if (rect.right < min_width && rect.bottom < min_height)
gdk_window_resize (window, min_width, min_height);
else if (rect.right < min_width)
rect.top = 0;
rect.right = max_width;
rect.bottom = max_height;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
+ dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
private->hint_max_width = rect.right - rect.left;
private->hint_max_height = rect.bottom - rect.top;
/* Again, check if the window is too large currently. */
- GetClientRect (private->xwindow, &rect);
+ GetClientRect (private->drawable.xwindow, &rect);
if (rect.right > max_width && rect.bottom > max_height)
gdk_window_resize (window, max_width, max_height);
else if (rect.right > max_width)
int diff;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
+
+ private = (GdkWindowPrivate*) window;
size_hints.length = sizeof (size_hints);
rect.top = 0;
rect.right = geometry->min_width;
rect.bottom = geometry->min_height;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
+ dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
private->hint_min_width = rect.right - rect.left;
private->hint_min_height = rect.bottom - rect.top;
/* Also check if he current size of the window is in bounds */
- GetClientRect (private->xwindow, &rect);
+ GetClientRect (private->drawable.xwindow, &rect);
if (rect.right < geometry->min_width
&& rect.bottom < geometry->min_height)
gdk_window_resize (window, geometry->min_width, geometry->min_height);
rect.top = 0;
rect.right = geometry->max_width;
rect.bottom = geometry->max_height;
- dwStyle = GetWindowLong (private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (private->xwindow, GWL_EXSTYLE);
+ dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
+ dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
private->hint_max_width = rect.right - rect.left;
private->hint_max_height = rect.bottom - rect.top;
/* Again, check if the window is too large currently. */
- GetClientRect (private->xwindow, &rect);
+ GetClientRect (private->drawable.xwindow, &rect);
if (rect.right > geometry->max_width
&& rect.bottom > geometry->max_height)
gdk_window_resize (window, geometry->max_width, geometry->max_height);
if (geom_mask & GDK_HINT_BASE_SIZE
&& geometry->base_width > 0
&& geometry->base_height > 0)
- if (!GetWindowPlacement (private->xwindow, &size_hints))
+ if (!GetWindowPlacement (private->drawable.xwindow, &size_hints))
g_warning ("gdk_window_set_hints: GetWindowPlacement failed");
else
{
size_hints.rcNormalPosition.top,
size_hints.rcNormalPosition.right,
size_hints.rcNormalPosition.bottom));
- if (!SetWindowPlacement (private->xwindow, &size_hints))
+ if (!SetWindowPlacement (private->drawable.xwindow, &size_hints))
g_warning ("gdk_window_set_hints: SetWindowPlacement failed");
}
gdk_window_set_title (GdkWindow *window,
const gchar *title)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
GDK_NOTE (MISC, g_print ("gdk_window_set_title: %#x %s\n",
- private->xwindow, title));
- if (!private->destroyed)
+ GDK_DRAWABLE_XID (window), title));
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- if (!SetWindowText (private->xwindow, title))
+ if (!SetWindowText (GDK_DRAWABLE_XID (window), title))
g_warning ("gdk_window_set_title: SetWindowText failed");
}
}
gdk_window_set_role (GdkWindow *window,
const gchar *role)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
-
GDK_NOTE (MISC, g_print ("gdk_window_set_role: %#x %s\n",
- private->xwindow, (role ? role : "NULL")));
+ GDK_DRAWABLE_XID (window), (role ? role : "NULL")));
/* XXX */
}
gdk_window_set_transient_for (GdkWindow *window,
GdkWindow *parent)
{
- GdkWindowPrivate *private;
- GdkWindowPrivate *parent_private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
- parent_private = (GdkWindowPrivate*) parent;
-
GDK_NOTE (MISC, g_print ("gdk_window_set_transient_for: %#x %#x\n",
- private->xwindow, parent_private->xwindow));
+ GDK_DRAWABLE_XID (window),
+ GDK_DRAWABLE_XID (parent)));
/* XXX */
}
GdkWindowPrivate *private;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- GdkColormapPrivate *colormap_private =
- (GdkColormapPrivate *) private->colormap;
-
GDK_NOTE (MISC, g_print ("gdk_window_set_background: %#x %s\n",
- private->xwindow,
+ private->drawable.xwindow,
gdk_color_to_string (color)));
if (private->bg_type == GDK_WIN32_BG_PIXMAP)
GdkPixmap *pixmap,
gint parent_relative)
{
- GdkWindowPrivate *window_private;
+ GdkWindowPrivate *private;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- window_private = (GdkWindowPrivate*) window;
+ private = (GdkWindowPrivate*) window;
- if (!window_private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- GdkColormapPrivate *colormap_private =
- (GdkColormapPrivate *) window_private->colormap;
- if (window_private->bg_type == GDK_WIN32_BG_PIXMAP)
+ if (private->bg_type == GDK_WIN32_BG_PIXMAP)
{
- if (window_private->bg_pixmap != NULL)
+ if (private->bg_pixmap != NULL)
{
- gdk_pixmap_unref (window_private->bg_pixmap);
- window_private->bg_pixmap = NULL;
+ gdk_pixmap_unref (private->bg_pixmap);
+ private->bg_pixmap = NULL;
}
- window_private->bg_type = GDK_WIN32_BG_NORMAL;
+ private->bg_type = GDK_WIN32_BG_NORMAL;
}
if (parent_relative)
{
- window_private->bg_type = GDK_WIN32_BG_PARENT_RELATIVE;
+ private->bg_type = GDK_WIN32_BG_PARENT_RELATIVE;
}
else if (!pixmap)
{
/* We must cache the pixmap in the WindowPrivate and
* paint it each time we get WM_ERASEBKGND
*/
- window_private->bg_type = GDK_WIN32_BG_PIXMAP;
- window_private->bg_pixmap = pixmap;
+ private->bg_type = GDK_WIN32_BG_PIXMAP;
+ private->bg_pixmap = pixmap;
gdk_pixmap_ref (pixmap);
}
}
HCURSOR xcursor;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
window_private = (GdkWindowPrivate*) window;
cursor_private = (GdkCursorPrivate*) cursor;
- if (!window_private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
if (!cursor)
xcursor = LoadCursor (NULL, IDC_ARROW);
xcursor = cursor_private->xcursor;
GDK_NOTE (MISC, g_print ("gdk_window_set_cursor: %#x %#x\n",
- window_private->xwindow, xcursor));
+ window_private->drawable.xwindow, xcursor));
window_private->xcursor = xcursor;
- SetCursor (xcursor);
- }
-}
-
-void
-gdk_window_set_colormap (GdkWindow *window,
- GdkColormap *colormap)
-{
- GdkWindowPrivate *window_private;
- GdkColormapPrivate *colormap_private;
-
- g_return_if_fail (window != NULL);
- g_return_if_fail (colormap != NULL);
-
- window_private = (GdkWindowPrivate*) window;
- colormap_private = (GdkColormapPrivate*) colormap;
-
- if (!window_private->destroyed)
- {
- /* XXX ??? */
- GDK_NOTE (MISC, g_print ("gdk_window_set_colormap: %#x %#x\n",
- window_private->xwindow,
- colormap_private->xcolormap));
- if (window_private->colormap)
- gdk_colormap_unref (window_private->colormap);
- window_private->colormap = colormap;
- gdk_colormap_ref (window_private->colormap);
-
- if (window_private->window_type != GDK_WINDOW_TOPLEVEL)
- gdk_window_add_colormap_windows (window);
}
}
gint *height,
gint *depth)
{
- GdkWindowPrivate *window_private;
+ g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
if (!window)
window = (GdkWindow*) &gdk_root_parent;
- window_private = (GdkWindowPrivate*) window;
-
- if (!window_private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
RECT rect;
- if (!GetClientRect (window_private->xwindow, &rect))
+ if (!GetClientRect (GDK_DRAWABLE_XID (window), &rect))
g_warning ("gdk_window_get_geometry: GetClientRect failed");
if (x)
if (height)
*height = rect.bottom - rect.top;
if (depth)
- *depth = gdk_window_get_visual (window)->depth;
+ *depth = gdk_drawable_get_visual (window)->depth;
}
}
GdkWindowPrivate *window_private;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
window_private = (GdkWindowPrivate*) window;
*y = window_private->y;
}
-void
-gdk_window_get_size (GdkWindow *window,
- gint *width,
- gint *height)
-{
- GdkWindowPrivate *window_private;
-
- g_return_if_fail (window != NULL);
-
- window_private = (GdkWindowPrivate*) window;
-
- if (width)
- *width = window_private->width;
- if (height)
- *height = window_private->height;
-}
-
-GdkVisual*
-gdk_window_get_visual (GdkWindow *window)
-{
- GdkWindowPrivate *window_private;
-
- g_return_val_if_fail (window != NULL, NULL);
-
- window_private = (GdkWindowPrivate*) window;
- /* Huh? ->parent is never set for a pixmap. We should just return
- * null immeditately. Well, do it then!
- */
- if (window_private->window_type == GDK_WINDOW_PIXMAP)
- return NULL;
-
- if (!window_private->destroyed)
- {
- if (window_private->colormap == NULL)
- return gdk_visual_get_system (); /* XXX ??? */
- else
- return ((GdkColormapPrivate *)window_private->colormap)->visual;
- }
-
- return NULL;
-}
-
-GdkColormap*
-gdk_window_get_colormap (GdkWindow *window)
-{
- GdkWindowPrivate *window_private;
-
- g_return_val_if_fail (window != NULL, NULL);
- window_private = (GdkWindowPrivate*) window;
-
- g_return_val_if_fail (window_private->window_type != GDK_WINDOW_PIXMAP, NULL);
- if (!window_private->destroyed)
- {
- if (window_private->colormap == NULL)
- return gdk_colormap_get_system (); /* XXX ??? */
- else
- return window_private->colormap;
- }
-
- return NULL;
-}
-
-GdkWindowType
-gdk_window_get_type (GdkWindow *window)
-{
- GdkWindowPrivate *window_private;
-
- g_return_val_if_fail (window != NULL, (GdkWindowType) -1);
-
- window_private = (GdkWindowPrivate*) window;
- return window_private->window_type;
-}
-
gint
gdk_window_get_origin (GdkWindow *window,
gint *x,
gint *y)
{
- GdkWindowPrivate *private;
gint return_val;
gint tx = 0;
gint ty = 0;
g_return_val_if_fail (window != NULL, 0);
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
POINT pt;
pt.x = 0;
pt.y = 0;
- ClientToScreen (private->xwindow, &pt);
+ ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
tx = pt.x;
ty = pt.y;
return_val = 1;
*y = ty;
GDK_NOTE (MISC, g_print ("gdk_window_get_origin: %#x: +%d+%d\n",
- private->xwindow, tx, ty));
+ GDK_DRAWABLE_XID (window), tx, ty));
return return_val;
}
POINT pt;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
private = (GdkWindowPrivate*) window;
if (x)
*x = 0;
if (y)
*y = 0;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
while (private->parent && ((GdkWindowPrivate*) private->parent)->parent)
private = (GdkWindowPrivate*) private->parent;
- if (private->destroyed)
+ if (private->drawable.destroyed)
return;
pt.x = 0;
pt.y = 0;
- ClientToScreen (private->xwindow, &pt);
+ ClientToScreen (private->drawable.xwindow, &pt);
if (x)
*x = pt.x;
if (y)
*y = pt.y;
GDK_NOTE (MISC, g_print ("gdk_window_get_root_origin: %#x: (%#x) +%d+%d\n",
- ((GdkWindowPrivate *) window)->xwindow,
- private->xwindow, pt.x, pt.y));
+ GDK_DRAWABLE_XID (window),
+ private->drawable.xwindow, pt.x, pt.y));
}
GdkWindow*
gint *y,
GdkModifierType *mask)
{
- GdkWindowPrivate *private;
GdkWindow *return_val;
POINT pointc, point;
HWND hwnd, hwndc;
+ g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
+
if (!window)
window = (GdkWindow*) &gdk_root_parent;
- private = (GdkWindowPrivate*) window;
-
return_val = NULL;
GetCursorPos (&pointc);
point = pointc;
- ScreenToClient (private->xwindow, &point);
+ ScreenToClient (GDK_DRAWABLE_XID (window), &point);
if (x)
*x = point.x;
gdk_window_at_pointer (gint *win_x,
gint *win_y)
{
- GdkWindowPrivate *private;
GdkWindow *window;
POINT point, pointc;
HWND hwnd, hwndc;
RECT rect;
- private = &gdk_root_parent;
-
GetCursorPos (&pointc);
point = pointc;
hwnd = WindowFromPoint (point);
gdk_window_get_parent (GdkWindow *window)
{
g_return_val_if_fail (window != NULL, NULL);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
return ((GdkWindowPrivate*) window)->parent;
}
GdkWindow*
gdk_window_get_toplevel (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_val_if_fail (window != NULL, NULL);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
- private = (GdkWindowPrivate*) window;
-
- while (private->window_type == GDK_WINDOW_CHILD)
- {
- window = ((GdkWindowPrivate*) window)->parent;
- private = (GdkWindowPrivate*) window;
- }
+ while (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_CHILD)
+ window = ((GdkWindowPrivate*) window)->parent;
return window;
}
GList *children;
g_return_val_if_fail (window != NULL, NULL);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return NULL;
/* XXX ??? */
- g_warning ("gdk_window_get_children ???");
+ g_warning ("gdk_window_get_children not implemented");
children = NULL;
return children;
GdkWindowPrivate *private;
g_return_val_if_fail (window != NULL, 0);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return 0;
return private->event_mask;
GdkWindowPrivate *private;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
private->event_mask = event_mask;
void
gdk_window_add_colormap_windows (GdkWindow *window)
{
- g_warning ("gdk_window_add_colormap_windows not implemented"); /* XXX */
+ g_warning ("gdk_window_add_colormap_windows not implemented");
}
-/*
- * This needs the X11 shape extension.
- * If not available, shaped windows will look
- * ugly, but programs still work. Stefan Wille
- */
void
gdk_window_shape_combine_mask (GdkWindow *window,
GdkBitmap *mask,
gint x, gint y)
{
- GdkWindowPrivate *window_private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- window_private = (GdkWindowPrivate*) window;
-
if (!mask)
{
GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %#x none\n",
- window_private->xwindow));
- SetWindowRgn (window_private->xwindow, NULL, TRUE);
+ GDK_DRAWABLE_XID (window)));
+ SetWindowRgn (GDK_DRAWABLE_XID (window), NULL, TRUE);
}
else
{
- GdkPixmapPrivate *pixmap_private;
+ GdkDrawablePrivate *pixmap_private;
HRGN hrgn;
DWORD dwStyle;
DWORD dwExStyle;
RECT rect;
/* Convert mask bitmap to region */
- pixmap_private = (GdkPixmapPrivate*) mask;
+ pixmap_private = (GdkDrawablePrivate*) mask;
hrgn = BitmapToRegion (pixmap_private->xwindow);
GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %#x %#x\n",
- window_private->xwindow,
+ GDK_DRAWABLE_XID (window),
pixmap_private->xwindow));
/* SetWindowRgn wants window (not client) coordinates */
- dwStyle = GetWindowLong (window_private->xwindow, GWL_STYLE);
- dwExStyle = GetWindowLong (window_private->xwindow, GWL_EXSTYLE);
- GetClientRect (window_private->xwindow, &rect);
+ dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+ dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
+ GetClientRect (GDK_DRAWABLE_XID (window), &rect);
AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
OffsetRgn (hrgn, -rect.left, -rect.top);
OffsetRgn (hrgn, x, y);
/* If this is a top-level window, add the title bar to the region */
- if (window_private->window_type == GDK_WINDOW_TOPLEVEL)
+ if (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_TOPLEVEL)
{
CombineRgn (hrgn, hrgn,
CreateRectRgn (0, 0, rect.right - rect.left, -rect.top),
RGN_OR);
}
- SetWindowRgn (window_private->xwindow, hrgn, TRUE);
+ SetWindowRgn (GDK_DRAWABLE_XID (window), hrgn, TRUE);
}
}
GdkWindowPrivate *private;
GList *tmp_list;
GdkEventFilter *filter;
+
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
private = (GdkWindowPrivate*) window;
- if (private && private->destroyed)
+ if (private && GDK_DRAWABLE_DESTROYED (window))
return;
-
+
if (private)
tmp_list = private->filters;
else
tmp_list = gdk_default_filters;
-
+
while (tmp_list)
{
filter = (GdkEventFilter *)tmp_list->data;
return;
tmp_list = tmp_list->next;
}
-
+
filter = g_new (GdkEventFilter, 1);
filter->function = function;
filter->data = data;
-
+
if (private)
private->filters = g_list_append (private->filters, filter);
else
GdkWindowPrivate *private;
GList *tmp_list, *node;
GdkEventFilter *filter;
+
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
private = (GdkWindowPrivate*) window;
-
- if(private)
+
+ if (private)
tmp_list = private->filters;
else
tmp_list = gdk_default_filters;
-
+
while (tmp_list)
{
filter = (GdkEventFilter *)tmp_list->data;
node = tmp_list;
tmp_list = tmp_list->next;
-
+
if ((filter->function == function) && (filter->data == data))
{
- if(private)
+ if (private)
private->filters = g_list_remove_link (private->filters, node);
else
- gdk_default_filters = g_list_remove_link (gdk_default_filters, tmp_list);
+ gdk_default_filters = g_list_remove_link (gdk_default_filters, node);
g_list_free_1 (node);
g_free (filter);
gdk_window_set_override_redirect (GdkWindow *window,
gboolean override_redirect)
{
- g_warning ("gdk_window_set_override_redirect not implemented"); /* XXX */
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ g_warning ("gdk_window_set_override_redirect not implemented");
}
void
GdkPixmap *pixmap,
GdkBitmap *mask)
{
- g_warning ("gdk_window_set_icon not implemented"); /* XXX */
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ if (GDK_DRAWABLE_DESTROYED (window))
+ return;
+
+ g_warning ("gdk_window_set_icon not implemented");
}
-void
+void
gdk_window_set_icon_name (GdkWindow *window,
gchar *name)
{
- GdkWindowPrivate *window_private;
-
g_return_if_fail (window != NULL);
- window_private = (GdkWindowPrivate*) window;
- if (window_private->destroyed)
- return;
+ g_return_if_fail (GDK_IS_WINDOW (window));
- if (!SetWindowText (window_private->xwindow, name))
+ if (GDK_DRAWABLE_DESTROYED (window))
+ return;
+
+ if (!SetWindowText (GDK_DRAWABLE_XID (window), name))
g_warning ("gdk_window_set_icon_name: SetWindowText failed");
}
gdk_window_set_group (GdkWindow *window,
GdkWindow *leader)
{
- g_warning ("gdk_window_set_group not implemented"); /* XXX */
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+ g_return_if_fail (leader != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (leader));
+
+ if (GDK_DRAWABLE_DESTROYED (window) || GDK_DRAWABLE_DESTROYED (leader))
+ return;
+
+ g_warning ("gdk_window_set_group not implemented");
}
void
gdk_window_set_decorations (GdkWindow *window,
GdkWMDecoration decorations)
{
- GdkWindowPrivate *window_private = (GdkWindowPrivate *) window;
LONG style, exstyle;
- style = GetWindowLong (window_private->xwindow, GWL_STYLE);
- exstyle = GetWindowLong (window_private->xwindow, GWL_EXSTYLE);
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ style = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+ exstyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
style &= (WS_OVERLAPPED|WS_POPUP|WS_CHILD|WS_MINIMIZE|WS_VISIBLE|WS_DISABLED
|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZE);
if (decorations & GDK_DECOR_MAXIMIZE)
style |= (WS_MAXIMIZEBOX);
- SetWindowLong (window_private->xwindow, GWL_STYLE, style);
+ SetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE, style);
}
void
gdk_window_set_functions (GdkWindow *window,
GdkWMFunction functions)
{
- GdkWindowPrivate *window_private = (GdkWindowPrivate *) window;
LONG style, exstyle;
- style = GetWindowLong (window_private->xwindow, GWL_STYLE);
- exstyle = GetWindowLong (window_private->xwindow, GWL_EXSTYLE);
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ style = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+ exstyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
style &= (WS_OVERLAPPED|WS_POPUP|WS_CHILD|WS_MINIMIZE|WS_VISIBLE|WS_DISABLED
|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZE|WS_CAPTION|WS_BORDER
if (functions & GDK_FUNC_MAXIMIZE)
style |= (WS_MAXIMIZEBOX);
- SetWindowLong (window_private->xwindow, GWL_STYLE, style);
+ SetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE, style);
}
GList *
void
gdk_window_set_child_shapes (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
- gdk_propagate_shapes ( private->xwindow, FALSE);
+ gdk_propagate_shapes (GDK_DRAWABLE_XID (window), FALSE);
}
void
gdk_window_merge_child_shapes (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ if (GDK_DRAWABLE_DESTROYED (window))
return;
- gdk_propagate_shapes (private->xwindow, TRUE);
+ gdk_propagate_shapes (GDK_DRAWABLE_XID (window), TRUE);
}
/*************************************************************
GdkWindowPrivate *private = (GdkWindowPrivate *)window;
g_return_val_if_fail (window != NULL, FALSE);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
return private->mapped;
}
GdkWindowPrivate *private = (GdkWindowPrivate *)window;
g_return_val_if_fail (window != NULL, FALSE);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
while (private &&
(private != &gdk_root_parent) &&
- (private->window_type != GDK_WINDOW_FOREIGN))
+ (private->drawable.window_type != GDK_WINDOW_FOREIGN))
{
if (!private->mapped)
return FALSE;
return TRUE;
}
-void
-gdk_drawable_set_data (GdkDrawable *drawable,
- const gchar *key,
- gpointer data,
- GDestroyNotify destroy_func)
-{
- g_dataset_set_data_full (drawable, key, data, destroy_func);
-}
-
-
/* Support for windows that can be guffaw-scrolled
* (See http://www.gtk.org/~otaylor/whitepapers/guffaw-scrolling.txt)
*/
{
enum { UNKNOWN, NO, YES };
static gint gravity_works = UNKNOWN;
-
+
if (gravity_works == UNKNOWN)
{
GdkWindowAttr attr;
attr.window_type = GDK_WINDOW_CHILD;
child = gdk_window_new (parent, &attr, GDK_WA_X | GDK_WA_Y);
-
+
gdk_window_set_static_win_gravity (child, TRUE);
gdk_window_resize (parent, 100, 110);
gdk_window_destroy (parent);
gdk_window_destroy (child);
-
+
gravity_works = ((y == -20) ? YES : NO);
}
-
+
return (gravity_works == YES);
}
static void
gdk_window_set_static_bit_gravity (GdkWindow *window, gboolean on)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-
g_return_if_fail (window != NULL);
- GDK_NOTE (MISC,
- g_print ("gdk_window_set_static_bit_gravity: Not implemented\n"));
+ GDK_NOTE (MISC, g_print ("gdk_window_set_static_bit_gravity: Not implemented\n"));
}
static void
gdk_window_set_static_win_gravity (GdkWindow *window, gboolean on)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-
g_return_if_fail (window != NULL);
GDK_NOTE (MISC,
{
GdkWindowPrivate *private = (GdkWindowPrivate *)window;
GList *tmp_list;
-
- g_return_val_if_fail (window != NULL, FALSE);
+ g_return_val_if_fail (window != NULL, FALSE);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
+
if (!use_static == !private->guffaw_gravity)
return TRUE;
if (use_static && !gdk_window_gravity_works ())
return FALSE;
-
+
private->guffaw_gravity = use_static;
-
- gdk_window_set_static_bit_gravity (window, use_static);
-
- tmp_list = private->children;
- while (tmp_list)
+
+ if (!GDK_DRAWABLE_DESTROYED (window))
{
- gdk_window_set_static_win_gravity (window, use_static);
+ gdk_window_set_static_bit_gravity (window, use_static);
- tmp_list = tmp_list->next;
+ tmp_list = private->children;
+ while (tmp_list)
+ {
+ gdk_window_set_static_win_gravity (window, use_static);
+
+ tmp_list = tmp_list->next;
+ }
}
-
+
return TRUE;
}
#define GDK_ROOT_WINDOW() ((guint32) HWND_DESKTOP)
#define GDK_ROOT_PARENT() ((GdkWindow *)&gdk_root_parent)
#define GDK_DISPLAY() NULL
-#define GDK_WINDOW_XDISPLAY(win) NULL
-#define GDK_WINDOW_XWINDOW(win) (((GdkWindowPrivate*) win)->xwindow)
+#define GDK_DRAWABLE_XDISPLAY(win) NULL
+#define GDK_DRAWABLE_XID(win) (((GdkDrawablePrivate*) win)->xwindow)
+#define GDK_WINDOW_XDISPLAY GDK_DRAWABLE_XDISPLAY
+#define GDK_WINDOW_XWINDOW GDK_DRAWABLE_XID
#define GDK_IMAGE_XDISPLAY(image) NULL
#define GDK_IMAGE_XIMAGE(image) (((GdkImagePrivate*) image)->ximage)
#define GDK_GC_XDISPLAY(gc) NULL
GTK_VER=1.3
GLIB = ../../../glib
-CFLAGS = $(OPTIMIZE) -I . -I .. -I ../.. -I $(WTKIT)/include -I $(GLIB) -DG_ENABLE_DEBUG -DHAVE_CONFIG_H -DGDK_VERSION=\"$(GTK_VER)\" -DNEAR= -DFAR=
+CFLAGS = $(OPTIMIZE) -I . -I .. -I ../.. -I $(WTKIT)/include -I $(GLIB) -DG_ENABLE_DEBUG -DHAVE_CONFIG_H -DGDK_VERSION=\"$(GTK_VER)\"
all: \
gdk/gdkprivate.h \
gdk.o \
gdkcc.o \
gdkcolor.o \
+ gdkcompat.o \
gdkcursor.o \
gdkdnd.o \
gdkdraw.o \
gdk.obj \
gdkcc.obj \
gdkcolor.obj \
+ gdkcompat.obj \
gdkcursor.obj \
gdkdnd.obj \
gdkdraw.obj \
GTK_TYPE_GDK_DRAG_ACTION
GTK_TYPE_GDK_DRAG_CONTEXT
GTK_TYPE_GDK_DRAG_PROTOCOL
+ GTK_TYPE_GDK_DRAWABLE_TYPE
GTK_TYPE_GDK_EVENT
GTK_TYPE_GDK_EVENT_MASK
GTK_TYPE_GDK_EVENT_TYPE
GTK_TYPE_GDK_WINDOW_ATTRIBUTES_TYPE
GTK_TYPE_GDK_WINDOW_CLASS
GTK_TYPE_GDK_WINDOW_HINTS
- GTK_TYPE_GDK_WINDOW_TYPE
GTK_TYPE_GDK_WM_DECORATION
GTK_TYPE_GDK_WM_FUNCTION
GTK_TYPE_JUSTIFICATION
gtk_invisible_new
gtk_item_deselect
gtk_item_factories_path_delete
+ gtk_item_factory_add_foreign
gtk_item_factory_construct
gtk_item_factory_create_item
gtk_item_factory_create_items
gtk_item_factory_dump_rc
gtk_item_factory_from_path
gtk_item_factory_from_widget
+ gtk_item_factory_get_item
+ gtk_item_factory_get_item_by_action
+ gtk_item_factory_get_type
gtk_item_factory_get_widget
gtk_item_factory_get_widget_by_action
gtk_item_factory_new
#endif
-#ifdef defined(G_OS_WIN32) || defined(G_HAVE_CYGWIN)
+#if defined(G_OS_WIN32) || defined(G_HAVE_CYGWIN)
#define FOLD(c) (tolower(c))
#else
#define FOLD(c) (c)
GLIB = ../../glib
INTL = ../../intl
-CFLAGS = $(OPTIMIZE) -I . -I .. -I $(GDKSYSDEP) -I $(GLIB) -I $(GLIB)/gmodule -I $(INTL) -DGTK_DISABLE_COMPAT_H
+CFLAGS = $(OPTIMIZE) -I . -I .. -I $(GDKSYSDEP) -I ../gdk -I $(GLIB) -I $(GLIB)/gmodule -I $(INTL) -DGTK_DISABLE_COMPAT_H
all : \
../config.h \
# More headers to use when autogenerating.
gdk_headers = \
- ../gdk/gdktypes.h \
- ../gdk/gdkrgb.h
+ ../gdk/gdkcc.h \
+ ../gdk/gdkcolor.h \
+ ../gdk/gdkcursor.h \
+ ../gdk/gdkdnd.h \
+ ../gdk/gdkdrawable.h \
+ ../gdk/gdkevents.h \
+ ../gdk/gdkfont.h \
+ ../gdk/gdkgc.h \
+ ../gdk/gdkim.h \
+ ../gdk/gdkimage.h \
+ ../gdk/gdkinput.h \
+ ../gdk/gdkpixmap.h \
+ ../gdk/gdkproperty.h \
+ ../gdk/gdkregion.h \
+ ../gdk/gdkrgb.h \
+ ../gdk/gdkselection.h \
+ ../gdk/gdktypes.h \
+ ../gdk/gdkvisual.h \
+ ../gdk/gdkwindow.h
../config.h : ../config.h.win32
cp ../config.h.win32 ../config.h
GLIB = ..\..\glib
INTL = ..\..\intl
-CFLAGS = -I. -I.. -I$(GDKSYSDEP) -I$(GLIB) -I$(GLIB)\gmodule -I$(INTL) -DGTK_DISABLE_COMPAT_H
+CFLAGS = -I. -I.. -I$(GDKSYSDEP) -I..\gdk -I$(GLIB) -I$(GLIB)\gmodule -I$(INTL) -DGTK_DISABLE_COMPAT_H
all : \
..\config.h \
# More headers to use when autogenerating.
gdk_headers = \
- ..\gdk\gdktypes.h \
- ..\gdk\gdkrgb.h
+ ..\gdk\gdkcc.h \
+ ..\gdk\gdkcolor.h \
+ ..\gdk\gdkcursor.h \
+ ..\gdk\gdkdnd.h \
+ ..\gdk\gdkdrawable.h \
+ ..\gdk\gdkevents.h \
+ ..\gdk\gdkfont.h \
+ ..\gdk\gdkgc.h \
+ ..\gdk\gdkim.h \
+ ..\gdk\gdkimage.h \
+ ..\gdk\gdkinput.h \
+ ..\gdk\gdkpixmap.h \
+ ..\gdk\gdkproperty.h \
+ ..\gdk\gdkregion.h \
+ ..\gdk\gdkrgb.h \
+ ..\gdk\gdkselection.h \
+ ..\gdk\gdktypes.h \
+ ..\gdk\gdkvisual.h \
+ ..\gdk\gdkwindow.h
..\config.h : ..\config.h.win32
copy ..\config.h.win32 ..\config.h
projects / gtk4.git / commitdiff